Python In-Place Integer Division Operator

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

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

Integer Example

The //= operator on integer operands stores the result of the mathematical floor division of both operands in the left-hand operands’ variable.

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

Float Example

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

>>> x = 9.0
>>> x //= 2
>>> x
4.0

Incompatible Data Type

What if two operands have an incompatible data type—unlike floats and integers? For example, if you try to divide a list by an integer variable?

>>> x = [1, 2, 3]
>>> x //= 3
Traceback (most recent call last):
  File "<pyshell#30>", line 1, in <module>
    x //= 3
TypeError: unsupported operand type(s) for //=: 'list' and 'int'

The result of incompatible division is a TypeError: unsupported operand type(s). You can fix it by using only compatible data types for the in-place integer division operation.

Can you use the division operator on custom objects? Yes!

Python In-Place Floor Division Magic Method

To use the in-place division operator //= on custom objects, you need to define the __floordiv__() method (“dunder method”, “magic method”) that takes two arguments self and other, updates the first argument self with the result of the integer division, and returns the updated object.

In the following code, you divide two Data objects using integer division on their contents contents:

class Data:

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

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

x = Data(9)
y = Data(2)

x //= y
print(x.data)
# 4

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

Note that if you want to override in-place division rather than in-place integer division, you need to define the __truediv__(self, other) method in your class.

Here’s an analogous example:

class Data:

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

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

x = Data(9)
y = Data(2)

x /= y
print(x.data)
# 4.5

Now Python internally performs the true division 9 / 2 == 4.5 and not the integer division 9 // 2 == 4.

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.