# operator-mod

The `%`

(modulo) operator yields the remainder from the division of
the first argument by the second. The numeric arguments are first
converted to a common type. A zero right argument raises the
ZeroDivisionError exception. The arguments may be floating point
numbers, e.g., `3.14%0.7`

equals `0.34`

(since `3.14`

equals `4*0.7
+ 0.34`.) The modulo operator always yields a result with the same
sign as its second operand (or zero); the absolute value of the result
is strictly smaller than the absolute value of the second
operand[5.2][5].

**Note:** While `abs(x%y) < abs(y)`

is true mathematically, for
floats it may not be true numerically due to roundoff. For example,
and assuming a platform on which a Python float is an IEEE 754
double-precision number, in order that `-1e-100 % 1e100`

have the same
sign as `1e100`

, the computed result is `-1e-100 + 1e100`

, which is
numerically exactly equal to `1e100`

. Function fmod() in the math
module returns a result whose sign matches the sign of the first
argument instead, and so returns `-1e-100`

in this case. Which
approach is more appropriate depends on the application.

The integer division and modulo operators are connected by the
following identity: `x == (x/y)\*y + (x%y)`

. Integer division and
modulo are also connected with the built-in function divmod():
`divmod(x, y) == (x/y, x%y)`

. These identities don’t hold for floating
point numbers; there similar identities hold approximately where `
x/y`is replaced by`

floor(x/y)`or`

floor(x/y) - 1`[5.3][6].

**Note**: If x is very close to an exact integer multiple of y, it’s
possible for `floor(x/y)`

to be one larger than `(x-x%y)/y`

due to
rounding. In such cases, Python returns the latter result, in order to
preserve that `divmod(x,y)[0] \* y + x % y`

be very close to `x`

.

In addition to performing the modulo operation on numbers, the `%`

operator is also overloaded by string and unicode objects to perform
string formatting (also known as interpolation). The syntax for string
formatting is described in the *[Python Library Reference][7]*,
section “Sequence Types”.

**Deprecated since release 2.3.** The floor division operator, the
modulo operator, and the divmod() function are no longer defined for
complex numbers. Instead, convert to a floating point number using the
abs() function if appropriate.

To support this operator in your own classes, implement the __mod__ method.