Python In-Place Multiplication Operator

[Overview] Python's In-Place Assignment Operators | Compound Operators

Python provides the operator x *= y to multiply two objects in-place by calculating the product x * y and assigning the result to the first operands variable name x. You can set up the in-place multiplication behavior for your own class by overriding the magic “dunder” method __imul__(self, other) in your class definition.

>>> x = 2
>>> x *= 3
>>> x
6

The expression x *= y is syntactical sugar for the longer-form x = x * y:

>>> x = 2
>>> x = x * 3
>>> x
6

Let’s explore some examples on different data types of the operands.

Integer Example

The *= operator on integer operands stores the mathematical product of both operands in the left-hand operands’ variable name.

>>> x = 2
>>> x *= 21
>>> x
42

Float Example

If at least one of the operands is a float value, the result is also a float—float is infectious!

>>> x = 2
>>> x *= 21.0
>>> x
42.0

String Example

Can we multiply a string with an integer in-place? Of course! The result is a new string object created by concatenating the first string multiple times as specified by the second integer operand. This is called string concatenation:

>>> x = 'learn! '
>>> x *= 3
>>> x
'learn! learn! learn! '

List Example

If the first operand is a list, the result of the in-place multiplication operation overwrites an existing list:

>>> my_list = ['Alice', 'Bob']
>>> my_list *= 3
>>> my_list
['Alice', 'Bob', 'Alice', 'Bob', 'Alice', 'Bob']

The in-place multiplication operator on lists doesn’t create a new list object but works on an existing list. Changing the list in-place for one variable x has side-effects. For instance, another variable my_list may point to the same object in memory that is updated through the use of in-place multiplication on any other variable pointing to that same object in memory.

>>> my_list = ['Alice', 'Bob']
>>> x = my_list
>>> x *= 3
>>> x
['Alice', 'Bob', 'Alice', 'Bob', 'Alice', 'Bob']
>>> my_list
['Alice', 'Bob', 'Alice', 'Bob', 'Alice', 'Bob']

Incompatible Data Type

What if two operands have an incompatible data type—unlike floats and integers? For example, if you try to multiply a list with a list in place?

>>> x = [1, 2]
>>> x *= [1, 2]
Traceback (most recent call last):
  File "<pyshell#12>", line 1, in <module>
    x *= [1, 2]
TypeError: can't multiply sequence by non-int of type 'list'

The result of incompatible addition is a TypeError. You can fix it by using only compatible data types for the in-place multiplication operation.

Can you use the operator on custom objects? Yes!

Python In-Place Multiplication Magic Method

To use the in-place multiplication operator *= on custom objects, define the __imul__() method (“dunder method”, “magic method”) that takes two arguments self and other, updates the first argument self with the result of the multiplication, and returns the updated object.

In the following code, you multiply two Data objects by combining their contents:

class Data:

    def __init__(self, data):
        self.data = data

    def __imul__(self, other):
        self.data *= other.data
        return self

x = Data(21)
y = Data(2)

x *= y
print(x.data)
# 42

You can see that the content of the first operand is updated as a result of the in-place multiplication operation.

Python In-Place Operators

In-place assignment operators (also called compound assignment operators) perform an operation in-place on a variable provided as first operand. They overwrite the value of the first operand variable with the result of the operation when performing the operator without assignment. For example, x += 3 is the same as x = x + 3 of first calculating the result of x +3 and then assigning it to the variable x.

Operator	Name	Short Example	Equivalent Long Example
=	In-place Assignment		x = 3
+=	In-place Addition	x += 3	x = x + 3
-=	In-place Subtraction	x -= 3	x = x - 3
*=	In-place Multiplication	x *= 3	x = x * 3
/=	In-place Division	x /= 3	x = x / 3
%=	In-place Modulo	x %= 3	x = x % 3
//=	In-place Integer Division	x //= 3	x = x // 3
**=	In-place Power	x **= 3	x = x ** 3
&=	In-place Bitwise And	x &= 3	x = x & 3
|=	In-place Bitwise Or	x |= 3	x = x | 3
^=	In-place Bitwise XOR	x ^= 3	x = x ^ 3
>>=	In-place Bitwise Shift Right	x >>= 3	x = x >> 3
<<=	In-place Bitwise Shift Left	x <<= 5	x = x << 5