# 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) &lt; 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.

rendered by a django application. hosted by webfaction.