ZetCode

Python __itruediv__ Method

Last modified April 8, 2025

This comprehensive guide explores Python's __itruediv__ method, the special method for in-place true division. We'll cover basic usage, operator overloading, practical examples, and best practices.

Basic Definitions

The __itruediv__ method implements the in-place true division operation (/=). It modifies the left operand in place rather than creating a new object.

Key characteristics: it must return the modified object (usually self), handles the /= operator, and performs floating-point division even with integers. It's called when no __truediv__ is present.

Basic __itruediv__ Implementation

Here's a simple implementation showing how __itruediv__ works with a custom class. The method modifies the instance's value.

basic_itruediv.py 
class Number:
    def __init__(self, value):
        self.value = value
    
    def __itruediv__(self, other):
        self.value /= other
        return self
    
num = Number(10)
num /= 2
print(num.value)  # Output: 5.0

This example shows the basic structure. The __itruediv__ method divides the instance's value by the right operand and returns the modified instance.

Note that even with integer inputs, true division always produces a float result. The method modifies the object in place rather than creating a new one.

Fraction Class with In-Place Division

This example demonstrates __itruediv__ in a more complex Fraction class that maintains numerator and denominator separately.

fraction_itruediv.py 
class Fraction:
    def __init__(self, numerator, denominator=1):
        self.numerator = numerator
        self.denominator = denominator
    
    def __itruediv__(self, other):
        if isinstance(other, Fraction):
            self.numerator *= other.denominator
            self.denominator *= other.numerator
        else:
            self.denominator *= other
        self._simplify()
        return self
    
    def _simplify(self):
        gcd_val = gcd(self.numerator, self.denominator)
        self.numerator //= gcd_val
        self.denominator //= gcd_val
    
    def __repr__(self):
        return f"Fraction({self.numerator}, {self.denominator})"

from math import gcd

f1 = Fraction(3, 4)
f1 /= Fraction(1, 2)
print(f1)  # Fraction(6, 4) simplified to Fraction(3, 2)

This Fraction class handles in-place division with both fractions and numbers. The __itruediv__ method updates the fraction's components and simplifies the result.

The method checks the type of the right operand to handle different division cases properly. It maintains the fraction in its simplest form after each operation.

Vector In-Place Division

This example shows vector division where each component is divided by a scalar value using the /= operator.

vector_itruediv.py 
class Vector:
    def __init__(self, *components):
        self.components = list(components)
    
    def __itruediv__(self, scalar):
        if scalar == 0:
            raise ValueError("Cannot divide by zero")
        self.components = [x / scalar for x in self.components]
        return self
    
    def __repr__(self):
        return f"Vector({', '.join(map(str, self.components))})"

v = Vector(2, 4, 6)
v /= 2
print(v)  # Vector(1.0, 2.0, 3.0)

The __itruediv__ method here divides each vector component by the scalar value. It includes protection against division by zero.

This implementation modifies the vector in place rather than creating a new Vector object. The components become floats even if divided by an integer.

Matrix In-Place Division

This more advanced example demonstrates matrix division where each element is divided by a scalar or another matrix element-wise.

matrix_itruediv.py 
class Matrix:
    def __init__(self, rows):
        self.rows = rows
    
    def __itruediv__(self, other):
        if isinstance(other, (int, float)):
            for i in range(len(self.rows)):
                for j in range(len(self.rows[i])):
                    self.rows[i][j] /= other
        elif isinstance(other, Matrix):
            for i in range(len(self.rows)):
                for j in range(len(self.rows[i])):
                    self.rows[i][j] /= other.rows[i][j]
        return self
    
    def __repr__(self):
        return '\n'.join([' '.join(map(str, row)) for row in self.rows])

m = Matrix([[1, 2], [3, 4]])
m /= 2
print(m)
# Output:
# 0.5 1.0
# 1.5 2.0

This Matrix class handles two types of division: by a scalar (dividing all elements) and by another matrix (element-wise division).

The __itruediv__ method checks the type of the right operand to determine which division operation to perform. It modifies the matrix in place.

Temperature Class with Unit Conversion

This example shows a Temperature class that supports in-place division with unit conversion considerations.

temperature_itruediv.py 
class Temperature:
    def __init__(self, kelvin):
        self.kelvin = kelvin
    
    def __itruediv__(self, other):
        if isinstance(other, Temperature):
            self.kelvin /= other.kelvin
        else:
            self.kelvin /= other
        return self
    
    @property
    def celsius(self):
        return self.kelvin - 273.15
    
    def __repr__(self):
        return f"Temperature(K={self.kelvin}, C={self.celsius})"

t = Temperature(300)
t /= 2
print(t)  # Temperature(K=150.0, C=-123.15)

The Temperature class stores values internally in Kelvin but can be divided by numbers or other Temperature objects. The __itruediv__ method modifies the internal Kelvin value.

The celsius property provides converted values but isn't used in the division operation. All calculations are performed on the Kelvin scale for consistency.

Best Practices

Source References

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Python tutorials.