# 5.6 二元算术运算符 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``` `| m_expr "%" u_expr` `a_expr` ::= ```m_expr | a_expr "+" m_expr | a_expr "-" 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) and `//` (floor division) operators yield the quotient of their 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.

/(除)运算符生成参数的商.数值型参数首先转换成通用类型,普通整数或长整数的除法计算结果是相同类型整数,结果就是对商的精确结果执行floor()函数的返回在值.除以零会引发ZeroDivisionError 异常.

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 operand5.1.

%(取模)计算第一个参数除以第二参数得到的余数.数值型参数首先转换成通用类型. 右面的参数为零, 会引发ZeroDivisionError异常. 参数可以浮点数,例如 3.14 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.2.

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.

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.

-(减)计算参数的差, 数值型的参数首先转换成通用类型.

#### 注脚

... operand5.1
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.
... 15.2
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`.