> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Python 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.
```python theme={"dark"}
x %= y
```
This syntax is semantically equivalent to the following, with the exception that the left operand `x` is evaluated only once:
```python theme={"dark"}
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:
```python theme={"dark"}
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:
```python theme={"dark"}
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:
```python theme={"dark"}
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:**
```python theme={"dark"}
a = 10
a %= 3
# Evaluates to 10 % 3. 'a' is rebound to the integer object 1.
```
**Float Evaluation:**
```python theme={"dark"}
b = 5.5
b %= 2.0
# Evaluates to 5.5 % 2.0. 'b' is rebound to the float object 1.5.
```
**Sign Rule Evaluation:**
```python theme={"dark"}
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:**
```python theme={"dark"}
e = 10
e %= 0
# Raises ZeroDivisionError: integer modulo by zero
```
**String Interpolation:**
```python theme={"dark"}
s = "Value: %d"
s %= 5
# Evaluates to "Value: %d" % 5. 's' is rebound to the string object "Value: 5".
```
Tired of Poor Python Skills? Fix That With Deep Grasping!
Learn More
