GNU Info

(python2.1-ref.info)Binary arithmetic operations

---

Next: Shifting operations Prev: Unary arithmetic operations Up: Expressions

---

Enter node , (file) or (file)node

Binary arithmetic operations
============================

The binary arithmetic operations have the conventional priority levels.
Note that some of these operations also apply to certain non-numeric
types.  Apart from the power operator, there are only two levels, one
for multiplicative operators and one for additive operators:

     m_expr:         u_expr | m_expr "*" u_expr
                   | m_expr "/" u_expr | m_expr "%" u_expr
     a_expr:         m_expr | aexpr "+" m_expr | aexpr "-" m_expr

The `*' (multiplication) operator yields the product of its arguments.
The arguments must either both be numbers, or one argument must be an
integer (plain or long) and the other must be a sequence.  In the
former case, the numbers are converted to a common type and then
multiplied together.  In the latter case, sequence repetition is
performed; a negative repetition factor yields an empty sequence.

The `/' (division) operator yields the quotient of its arguments.  The
numeric arguments are first converted to a common type.  Plain or long
integer division yields an integer of the same type; the result is that
of mathematical division with the `floor' function applied to the
result.  Division by zero raises the `ZeroDivisionError' exception.

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 second operand.

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 and complex numbers; there similar identities hold approximately
where `x/y' is replaced by `floor(x/y)') or `floor(x/y) - 1' (for
floats),(1) or `floor((x/y).real)' (for complex).

The `+' (addition) operator yields the sum of its arguments.  The
arguments must either both be numbers or both sequences of the same
type.  In the former case, the numbers are converted to a common type
and then added together.  In the latter case, the sequences are
concatenated.

The `-' (subtraction) operator yields the difference of its arguments.
The numeric arguments are first converted to a common type.

---------- Footnotes ----------

(1)  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'.