Python In-Place Assignment 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.

You can watch me go over all of these operators in the following video:

We’ll rush over all in-place operators one-by-one next!

Python In-Place Addition

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

>>> x = 1
>>> x += 2
>>> x
3

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

>>> x = 1
>>> x = x + 2
>>> x
3

Related Tutorial: Python In-Place Addition

Python In-Place Subtraction

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

>>> x = 3
>>> x -= 2
>>> x
1

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

>>> x = 3
>>> x = x - 2
>>> x
1

Related Tutorial: Python In-Place Subtraction

Python In-Place Multiplication

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

Related Tutorial: Python In-Place Multiplication

Python In-Place Division

Python’s in-place division operator x /= y divides two objects in-place by calculating x / y and assigning the result to the first operands variable name x. Set up in-place division for your own class by overriding the magic “dunder” method __truediv__(self, other) in your class definition.

>>> x = 4
>>> x /= 2
>>> x
2

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

>>> x = 4
>>> x = x / 2
>>> x
2

Related Tutorial: Python In-Place Division

Python In-Place Modulo

Python provides the operator x %= y to calculate the modulo operation x % y, and assign the result in-place to the first operands variable x. You can set up the in-place modulo behavior for your own class by overriding the magic “dunder” method __imod__(self, other) in your class definition.

>>> x = 9
>>> x %= 4
>>> x
1

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

>>> x = 9
>>> x = x % 4
>>> x
1

Related Tutorial: Python In-Place Modulo

Python In-Place Integer Division

Python’s in-place integer division operator x //= y divides two objects in-place by calculating x // y and assigning the result to the first operands variable name x. Set up in-place integer (or floor) division for your own class by overriding the magic “dunder” method __floordiv__(self, other) in your class definition.

>>> x = 5
>>> x //= 2
>>> x
2

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

>>> x = 5
>>> x = x // 2
>>> x
2

Related Tutorial: Python In-Place Integer Division

Python In-Place Exponentiation

Python provides the in-place exponentiation operator x **= y that raises x to the power of y using x ** y and assigns the result to the first operands variable name x. You can set up the in-place exponentiation behavior for your own class by overriding the magic “dunder” method __ipow__(self, other) in your class definition.

>>> x = 2
>>> x **= 3
>>> x
8

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

>>> x = 2
>>> x = x ** 3
>>> x
8

Related Tutorial: Python In-Place Exponentiation

Python In-Place Bitwise AND

Python’s in-place bitwise AND operator x &= y calcualtes bitwise-and x & y and assigns the result to the first operand x. To set it up for your own class, override the magic “dunder” method __iand__(self, other) in your class definition.

>>> x = 1
>>> x &= 2
>>> x
0

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

>>> x = 1
>>> x = x & 2
>>> x
3

Related Tutorial: Python In-Place Bitwise AND

Python In-Place Bitwise OR

Python’s A |= B applies the | operator in place. Thus, it is semantically identical to the longer-form version A = A | B of first performing the operation A | B and then assigning the result to the variable A.

The following minimal example creates two Boolean variables A and B and performs the in-place B |= A operation to perform a logical OR operation B | A and assigning the result to the first operand B that becomes True:

>>> A = True
>>> B = False
>>> B |= A
>>> B
True

In this example, you’ve seen this in-place operation on Boolean operands. But the | operator is overloaded in Python. The three most frequent use cases for the | and |= operators are the following:

• Python Sets: set union operator
• Python Dictionaries: dictionary update operator
• Python Booleans: logical OR operator

Related Tutorial: Python In-Place Bitwise OR

Python In-Place Bitwise XOR

Python’s in-place bitwise XOR operator x ^= y calcualtes bitwise XOR x ^ y and assigns the result to the first operand x. To set this up for your own class, override the magic “dunder” method __ixor__(self, other) in your class definition.

>>> x = 1
>>> x ^= 2
>>> x
3

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

>>> x = 1
>>> x = x ^ 2
>>> x
3

Related Tutorial: Python In-Place Bitwise XOR

Python In-Place Bitwise Right-Shift

Python’s in-place bitwise right-shift operator x >>= y calculates the right-shift operation x >> y, and assigns the result to the first operands variable name x. You can set up the in-place right-shift behavior in your own class by overriding the magic “dunder” method __irshift__(self, other) in your class definition.

>>> x = 8
>>> x >>= 2
>>> x
2

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

>>> x = 8
>>> x = x >> 2
>>> x
2

Related Tutorial: Python In-Place Bitwise Right-Shift

Python In-Place Bitwise Left-Shift

Python’s in-place bitwise left-shift operator x <<= y calculates the left-shift operation x << y, and assigns the result to the first operands variable name x. You can set up the in-place left-shift behavior in your own class by overriding the magic “dunder” method __ilshift__(self, other) in your class definition.

>>> x = 8
>>> x <<= 2
>>> x
32

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

>>> x = 8
>>> x = x << 2
>>> x
32

Related Tutorial: Python In-Place Bitwise Left-Shift

Python In-Place Magic Methods

The following table provides the names of the magic methods you need to define to enable in-place operators on your custom class:

In the following code example, we create a custom class Data and define our “magic” double-underscore methods so that we can perform in-place computations on objects of this class.

class Data:

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

    def __iadd__(self, other):
        self.data += other.data
        return self

    def __isub__(self, other):
        self.data -= other.data
        return self

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

    def __truediv__(self, other):
        self.data /= other.data
        return self

    def __imod__(self, other):
        self.data %= other.data
        return self

    def __floordiv__(self, other):
        self.data //= other.data
        return self

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

    def __iand__(self, other):
        self.data &= other.data
        return self

    def __ior__(self, other):
        self.data |= other.data
        return self

    def __ixor__(self, other):
        self.data ^= other.data
        return self

    def __irshift__(self, other):
        self.data >>= other.data
        return self

    def __ilshift__(self, other):
        self.data <<= other.data
        return self
    

Let’s try these out!

# In-Place Addition
x = Data(3)
y = Data(2)
x += y
print(x.data)
# 5

# In-Place Subtraction
x = Data(3)
y = Data(2)
x -= y
print(x.data)
# 1

# In-Place Multiplication
x = Data(3)
y = Data(2)
x *= y
print(x.data)
# 6

# In-Place Division
x = Data(3)
y = Data(2)
x /= y
print(x.data)
# 1.5

# In-Place Modulo
x = Data(3)
y = Data(2)
x %= y
print(x.data)
# 1

# In-Place Integer Division
x = Data(3)
y = Data(2)
x //= y
print(x.data)
# 1

# In-Place Power
x = Data(3)
y = Data(2)
x **= y
print(x.data)
# 9

# In-Place Bitwise AND
x = Data(3)
y = Data(2)
x &= y
print(x.data)
# 2

# In-Place Bitwise OR
x = Data(3)
y = Data(2)
x |= y
print(x.data)
# 3

# In-Place Bitwise XOR
x = Data(3)
y = Data(2)
x ^= y
print(x.data)
# 1

# In-Place Bitwise Right-Shift
x = Data(3)
y = Data(2)
x >>= y
print(x.data)
# 0

# In-Place Bitwise Left-Shift
x = Data(3)
y = Data(2)
x <<= y
print(x.data)
# 12