Modulo Assignment

The %= operator is an augmented assignment operator that performs a modulo operation—or printf-style formatting—on two operands and assigns the resulting value to the left operand. For numeric types, it evaluates the division of the left variable by the right expression and updates the left variable’s reference to point to the remainder.

x %= y

This syntax is semantically equivalent to the following, with the exception that the left operand x is evaluated only once:

x = x % y

Technical Mechanics

• Evaluation Order: The right-hand expression is fully evaluated before the modulo operation occurs.
• Sign Rule: For numeric operations, Python’s modulo operator (%) ensures the remainder always takes the mathematical sign of the divisor (the right operand). Consequently, %= will assign a value matching the sign of the right operand.
• Mathematical Constraints: If the right operand evaluates to zero during a numeric modulo operation, the operation raises a ZeroDivisionError.
• Type Support: The operator natively supports numeric types, including int and float. Additionally, %= is natively supported by str and bytes objects to perform printf-style string formatting and interpolation.

Object Model Implementation

When the Python interpreter encounters x %= y, it attempts to invoke the in-place magic method __imod__ on the left operand and assigns the return value back to the left identifier:

x = x.__imod__(y)

If the left operand’s class does not implement __imod__, or if that method returns NotImplemented, Python falls back to evaluating the standard modulo operator (x % y). This fallback process first attempts the left operand’s __mod__ method:

x = x.__mod__(y)

If __mod__ is not implemented or returns NotImplemented (typically due to incompatible types), Python relies on its right-operand reflection semantics and attempts the right operand’s __rmod__ method:

x = y.__rmod__(x)

Because Python’s core numeric types (int, float) and sequence types (str, bytes) are immutable, they do not implement __imod__. Therefore, %= does not mutate the original object in memory. Instead, it calculates the new value using the __mod__ (or __rmod__) fallback and rebinds the left-hand identifier to a newly allocated object containing the result.

Behavior Examples

Integer Evaluation:

a = 10
a %= 3  

# Evaluates to 10 % 3. 'a' is rebound to the integer object 1.

Float Evaluation:

b = 5.5
b %= 2.0  

# Evaluates to 5.5 % 2.0. 'b' is rebound to the float object 1.5.

Sign Rule Evaluation:

c = -10
c %= 3  

# Divisor is positive. 'c' is rebound to 2.

d = 10
d %= -3 

# Divisor is negative. 'd' is rebound to -2.

Zero Division Constraint:

e = 10
e %= 0

# Raises ZeroDivisionError: integer modulo by zero

String Interpolation:

s = "Value: %d"
s %= 5

# Evaluates to "Value: %d" % 5. 's' is rebound to the string object "Value: 5".

Master Python with Deep Grasping Methodology!

Learn More