Python *= Operator: How It Works and When to Use It
Learn how Python's *= operator works, including in-place semantics for mutable types and how to control it in your own classes.

The *= operator is an augmented assignment that multiplies a variable by a value and assigns the result back. For example, x *= 2 is roughly equivalent to x = x * 2, but the exact behavior depends on the type of x. For mutable types, the operation may modify the object in place; for immutable types, it always creates a new object and rebinds the name. Understanding this distinction is essential for writing predictable code and for designing classes that behave intuitively.
Augmented Assignment Semantics
When Python encounters a *= b, it does not simply expand to a = a * b. Instead, it follows a specific lookup order. First, it checks whether the type of a defines __imul__. If it does, Python calls a.__imul__(b) and assigns the returned value back to a. If __imul__ is not defined, Python falls back to a.__mul__(b) and then rebinds a to that result. This is why the behavior can differ between mutable and immutable types.
The same pattern applies to other augmented assignment operators like +=, -=, and /=. Each operator has a corresponding in-place method (__iadd__, __isub__, etc.) that takes precedence over the regular binary method. The fallback ensures that even if a type does not implement the in-place variant, the operation still works, but it behaves like a normal multiplication followed by assignment.
In-Place vs Rebinding for Mutable and Immutable Types
The key difference lies in whether the object itself is modified or a new object is created. For immutable types—such as int, float, str, and tuple—there is no __imul__ method because the object cannot be changed. Python therefore always calls __mul__, creates a new object, and rebinds the variable. The original object remains unchanged, which is consistent with immutability.
For mutable types, the story is different. A list defines __imul__, which extends the list in place by repeating its elements. The variable still points to the same list object, but its contents have changed. This distinction matters when multiple variables reference the same object: mutating one will affect all references, whereas rebinding only affects the one variable.
Behavior with Common Built-in Types
Let's look at concrete examples for the most common built-in types.
# List: in-place mutation
lst = [1, 2]
original_id = id(lst)
lst *= 2
print(lst) # [1, 2, 1, 2]
print(id(lst) == original_id) # TrueFor a list, *= calls __imul__, which repeats the elements and modifies the list object itself. The identity remains the same.
# Tuple: creates a new tuple
tup = (1, 2)
original_id = id(tup)
tup *= 2
print(tup) # (1, 2, 1, 2)
print(id(tup) == original_id) # FalseTuples are immutable, so *= falls back to __mul__, producing a new tuple. The original tuple is unchanged.
# String: creates a new string
s = "ab"
s *= 3
print(s) # "ababab"Strings are also immutable; *= creates a new string object.
# Integer: creates a new integer
n = 5
n *= 3
print(n) # 15Integers are immutable, so the variable is rebound to a new integer object.
Controlling Behavior in Custom Classes
If you are designing a class that represents a mutable container or a mathematical object, you may want to implement __imul__ to allow efficient in-place multiplication. Without it, Python will fall back to __mul__, which typically returns a new instance and may be less efficient.
Here is a simple example of a class that implements both methods:
class Vector:
def __init__(self, values):
self.values = list(values)
def __mul__(self, scalar):
return Vector([v * scalar for v in self.values])
def __imul__(self, scalar):
for i in range(len(self.values)):
self.values[i] *= scalar
return selfWith this implementation, v *= 2 modifies the existing Vector instance, while v = v * 2 creates a new Vector. This distinction is useful when you want to preserve object identity or avoid allocating a new object in performance-sensitive code.
Performance and Memory Considerations
In-place multiplication can reduce memory churn for mutable types. For a large list, lst *= n extends the list by reusing the existing allocation when possible, whereas lst = lst * n creates a completely new list and then reassigns the variable. The latter requires allocating a new list and copying all elements, which is more work. However, the exact performance gain depends on the implementation and the size of the data; it is not a guarantee of a specific speedup.
For immutable types, there is no in-place benefit because a new object is always created. The operation is equivalent to x = x * y in terms of memory usage and speed. If you are repeatedly multiplying a large immutable structure, consider whether a mutable alternative (like a list instead of a tuple) would be more appropriate for your use case.
When defining custom classes, implementing __imul__ can avoid unnecessary allocations. But do not over-optimize prematurely. Only add __imul__ when you have measured that object creation is a bottleneck or when in-place semantics are part of the class's contract.
Common Mistakes and Edge Cases
The most common mistake with *= is assuming that it always mutates the object in place. This is only true for types that implement __imul__. For immutable types, the variable is rebound, and any other references to the original object remain unchanged. Consider this aliasing scenario:
a = [1, 2]
b = a
a *= 2
print(b) # [1, 2, 1, 2]Because a and b reference the same list, mutating a also changes b. If you intended to create a new list, you should use a = a * 2 instead.
Another edge case is using *= with incompatible types. The target must be an assignable expression, so you cannot write "abc" *= 3 directly. With a variable, *= works for supported combinations:
s = "abc"
s *= 3 # "abcabcabc"
t = "abc"
t *= [1] # TypeError: can't multiply sequence by non-int of type 'list'The multiplication s *= 3 is valid because a string can be multiplied by an integer. The multiplication t *= [1] raises a TypeError because a list is not a valid multiplier for a string.
Finally, augmented assignment is a statement, not an expression. You cannot write y = (x *= 2); this is a syntax error. The operator is designed to be used as a standalone statement, and trying to embed it in a larger expression will fail.
Try matching browser tools
All toolsSmall utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.
Related Python guides
All Python guidesPython iter(): How the Built-in Function Works
Explains Python's iter() built-in: how it creates iterators, the two-argument sentinel form, custom iterator classes, and common edge cases.
Python Pika: Queues, Exchanges, Routing Keys, and Acknowledgements
Learn how to use Python's Pika client with RabbitMQ: declare queues and exchanges, publish with routing keys, consume messages, and handle acknowledgements reliably.
Python Kafka: kafka-python vs Confluent Client
python kafka python vs confluent kafka: Compare kafka-python and Confluent Kafka Python clients: API differences, performance, feature coverage, and when to choose eac...
Python Kafka Offsets, Partitions, and Manual Commits
Learn how Kafka offsets and partitions work and how to manually commit offsets in Python consumers with kafka-python and confluent-kafka. Covers sync vs async commits, rebalances, and seeking.
More in Python
All Python guidesThe guides filed next to this one in Python, in library order.