5. 表达式 ¶

name ::=  othername
					

atom      ::=  identifier | literal | enclosure
enclosure ::=  parenth_form | list_display
               | generator_expression | dict_display | set_display
               | string_conversion | yield_atom
					

literal ::=  stringliteral | integer | longinteger
             | floatnumber | imagnumber
					

parenth_form ::=  "(" [expression_list] ")"
					

list_display        ::=  "[" [expression_list | list_comprehension] "]"
list_comprehension  ::=  expression list_for
list_for            ::=  "for" target_list "in" old_expression_list [list_iter]
old_expression_list ::=  old_expression [("," old_expression)+ [","]]
old_expression      ::=  or_test | old_lambda_expr
list_iter           ::=  list_for | list_if
list_if             ::=  "if" old_expression [list_iter]
					

comprehension ::=  expression comp_for
comp_for      ::=  "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" expression_nocond [comp_iter]
					

generator_expression ::=  "(" expression comp_for ")"
					

dict_display       ::=  "{" [key_datum_list | dict_comprehension] "}"
key_datum_list     ::=  key_datum ("," key_datum)* [","]
key_datum          ::=  expression ":" expression
dict_comprehension ::=  expression ":" expression comp_for
					

set_display ::=  "{" (expression_list | comprehension) "}"
					

string_conversion ::=  "`" expression_list "`"
					

yield_atom       ::=  "(" yield_expression ")"
yield_expression ::=  "yield" [expression_list]
					

5.2.10.1. Generator-iterator methods ¶

This subsection describes the methods of a generator iterator. They can be used to control the execution of a generator function.

Note that calling any of the generator methods below when the generator is already executing raises a ValueError 异常。

generator. next ( ) ¶

Starts the execution of a generator function or resumes it at the last executed yield expression. When a generator function is resumed with a next() method, the current yield expression always evaluates to None . The execution then continues to the next yield expression, where the generator is suspended again, and the value of the expression_list is returned to next() ‘s caller. If the generator exits without yielding another value, a StopIteration 异常被引发。

generator. send ( value ) ¶

再继续执行并把值 send (发送) 到生成器函数。 value argument becomes the result of the current yield expression. The send() method returns the next value yielded by the generator, or raises StopIteration if the generator exits without yielding another value. When send() is called to start the generator, it must be called with None as the argument, because there is no yield expression that could receive the value.

generator. throw ( type [ , value [ , traceback ] ] ) ¶

Raises an exception of type type at the point where generator was paused, and returns the next value yielded by the generator function. If the generator exits without yielding another value, a StopIteration exception is raised. If the generator function does not catch the passed-in exception, or raises a different exception, then that exception propagates to the caller.

generator. close ( ) ¶

引发 GeneratorExit at the point where the generator function was paused. If the generator function then raises StopIteration (by exiting normally, or due to already being closed) or GeneratorExit (by not catching the exception), close returns to its caller. If the generator yields a value, a RuntimeError is raised. If the generator raises any other exception, it is propagated to the caller. close() does nothing if the generator has already exited due to an exception or normal exit.

Here is a simple example that demonstrates the behavior of generators and generator functions:

>>> def echo(value=None):
...     print "Execution starts when 'next()' is called for the first time."
...     try:
...         while True:
...             try:
...                 value = (yield value)
...             except Exception, e:
...                 value = e
...     finally:
...         print "Don't forget to clean up when 'close()' is called."
...
>>> generator = echo(1)
>>> print generator.next()
Execution starts when 'next()' is called for the first time.
1
>>> print generator.next()
None
>>> print generator.send(2)
2
>>> generator.throw(TypeError, "spam")
TypeError('spam',)
>>> generator.close()
Don't forget to clean up when 'close()' is called.
					

另请参阅

PEP 0342 - 协程凭借增强生成器

The proposal to enhance the API and syntax of generators, making them usable as simple coroutines.

5.3. 基元 ¶

Primaries represent the most tightly bound operations of the language. Their syntax is:

primary ::=  atom | attributeref | subscription | slicing | call
					

5.3.1. Attribute references ¶

An attribute reference is a primary followed by a period and a name:

attributeref ::=  primary "." identifier
					

The primary must evaluate to an object of a type that supports attribute references, e.g., a module, list, or an instance. This object is then asked to produce the attribute whose name is the identifier. If this attribute is not available, the exception AttributeError is raised. Otherwise, the type and value of the object produced is determined by the object. Multiple evaluations of the same attribute reference may yield different objects.

5.3.2. Subscriptions ¶

A subscription selects an item of a sequence (string, tuple or list) or mapping (dictionary) object:

subscription ::=  primary "[" expression_list "]"
					

The primary must evaluate to an object of a sequence or mapping type.

If the primary is a mapping, the expression list must evaluate to an object whose value is one of the keys of the mapping, and the subscription selects the value in the mapping that corresponds to that key. (The expression list is a tuple except if it has exactly one item.)

If the primary is a sequence, the expression (list) must evaluate to a plain integer. If this value is negative, the length of the sequence is added to it (so that, e.g., x[-1] selects the last item of x .) The resulting value must be a nonnegative integer less than the number of items in the sequence, and the subscription selects the item whose index is that value (counting from zero).

A string’s items are characters. A character is not a separate data type but a string of exactly one character.

5.3.3. Slicings ¶

A slicing selects a range of items in a sequence object (e.g., a string, tuple or list). Slicings may be used as expressions or as targets in assignment or del statements. The syntax for a slicing:

slicing          ::=  simple_slicing | extended_slicing
simple_slicing   ::=  primary "[" short_slice "]"
extended_slicing ::=  primary "[" slice_list "]"
slice_list       ::=  slice_item ("," slice_item)* [","]
slice_item       ::=  expression | proper_slice | ellipsis
proper_slice     ::=  short_slice | long_slice
short_slice      ::=  [lower_bound] ":" [upper_bound]
long_slice       ::=  short_slice ":" [stride]
lower_bound      ::=  expression
upper_bound      ::=  expression
stride           ::=  expression
ellipsis         ::=  "..."
					

There is ambiguity in the formal syntax here: anything that looks like an expression list also looks like a slice list, so any subscription can be interpreted as a slicing. Rather than further complicating the syntax, this is disambiguated by defining that in this case the interpretation as a subscription takes priority over the interpretation as a slicing (this is the case if the slice list contains no proper slice nor ellipses). Similarly, when the slice list has exactly one short slice and no trailing comma, the interpretation as a simple slicing takes priority over that as an extended slicing.

The semantics for a simple slicing are as follows. The primary must evaluate to a sequence object. The lower and upper bound expressions, if present, must evaluate to plain integers; defaults are zero and the sys.maxint , respectively. If either bound is negative, the sequence’s length is added to it. The slicing now selects all items with index k 这样 i <= k < j where i and j are the specified lower and upper bounds. This may be an empty sequence. It is not an error if i or j lie outside the range of valid indexes (such items don’t exist so they aren’t selected).

The semantics for an extended slicing are as follows. The primary must evaluate to a mapping object, and it is indexed with a key that is constructed from the slice list, as follows. If the slice list contains at least one comma, the key is a tuple containing the conversion of the slice items; otherwise, the conversion of the lone slice item is the key. The conversion of a slice item that is an expression is that expression. The conversion of an ellipsis slice item is the built-in Ellipsis object. The conversion of a proper slice is a slice object (see section 标准类型层次结构 ) whose start , stop and step attributes are the values of the expressions given as lower bound, upper bound and stride, respectively, substituting None for missing expressions.

5.3.4. Calls ¶

调用调用可调用对象 (如 function ) 采用可能空的一系列 arguments :

call                 ::=  primary "(" [argument_list [","]
                          | expression genexpr_for] ")"
argument_list        ::=  positional_arguments ["," keyword_arguments]
                            ["," "*" expression] ["," keyword_arguments]
                            ["," "**" expression]
                          | keyword_arguments ["," "*" expression]
                            ["," "**" expression]
                          | "*" expression ["," keyword_arguments] ["," "**" expression]
                          | "**" expression
positional_arguments ::=  expression ("," expression)*
keyword_arguments    ::=  keyword_item ("," keyword_item)*
keyword_item         ::=  identifier "=" expression
					

A trailing comma may be present after the positional and keyword arguments but does not affect the semantics.

The primary must evaluate to a callable object (user-defined functions, built-in functions, methods of built-in objects, class objects, methods of class instances, and certain class instances themselves are callable; extensions may define additional callable object types). All argument expressions are evaluated before the call is attempted. Please refer to section 函数定义 for the syntax of formal 参数 lists.

If keyword arguments are present, they are first converted to positional arguments, as follows. First, a list of unfilled slots is created for the formal parameters. If there are N positional arguments, they are placed in the first N slots. Next, for each keyword argument, the identifier is used to determine the corresponding slot (if the identifier is the same as the first formal parameter name, the first slot is used, and so on). If the slot is already filled, a TypeError exception is raised. Otherwise, the value of the argument is placed in the slot, filling it (even if the expression is None , it fills the slot). When all arguments have been processed, the slots that are still unfilled are filled with the corresponding default value from the function definition. (Default values are calculated, once, when the function is defined; thus, a mutable object such as a list or dictionary used as default value will be shared by all calls that don’t specify an argument value for the corresponding slot; this should usually be avoided.) If there are any unfilled slots for which no default value is specified, a TypeError exception is raised. Otherwise, the list of filled slots is used as the argument list for the call.

CPython 实现细节： An implementation may provide built-in functions whose positional parameters do not have names, even if they are ‘named’ for the purpose of documentation, and which therefore cannot be supplied by keyword. In CPython, this is the case for functions implemented in C that use PyArg_ParseTuple() to parse their arguments.

If there are more positional arguments than there are formal parameter slots, a TypeError exception is raised, unless a formal parameter using the syntax *identifier is present; in this case, that formal parameter receives a tuple containing the excess positional arguments (or an empty tuple if there were no excess positional arguments).

If any keyword argument does not correspond to a formal parameter name, a TypeError exception is raised, unless a formal parameter using the syntax **identifier is present; in this case, that formal parameter receives a dictionary containing the excess keyword arguments (using the keywords as keys and the argument values as corresponding values), or a (new) empty dictionary if there were no excess keyword arguments.

若句法 *expression 出现在函数调用中， 表达式 must evaluate to an iterable. Elements from this iterable are treated as if they were additional positional arguments; if there are positional arguments x1 , ..., xN ，和 表达式 evaluates to a sequence y1 , ..., yM , this is equivalent to a call with M+N positional arguments x1 , ..., xN , y1 , ..., yM .

A consequence of this is that although the *expression syntax may appear after some keyword arguments, it is processed before the keyword arguments (and the **expression argument, if any – see below). So:

>>> def f(a, b):
...  print a, b
...
>>> f(b=1, *(2,))
2 1
>>> f(a=1, *(2,))
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: f() got multiple values for keyword argument 'a'
>>> f(1, *(2,))
1 2
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
TypeError: f() got multiple values for keyword argument 'a'
					

It is unusual for both keyword arguments and the *expression syntax to be used in the same call, so in practice this confusion does not arise.

若句法 **expression 出现在函数调用中， 表达式 must evaluate to a mapping, the contents of which are treated as additional keyword arguments. In the case of a keyword appearing in both 表达式 and as an explicit keyword argument, a TypeError 异常被引发。

形式参数使用句法 *identifier or **identifier cannot be used as positional argument slots or as keyword argument names. Formal parameters using the syntax (sublist) cannot be used as keyword argument names; the outermost sublist corresponds to a single unnamed argument slot, and the argument value is assigned to the sublist using the usual tuple assignment rules after all other parameter processing is done.

A call always returns some value, possibly None , unless it raises an exception. How this value is computed depends on the type of the callable object.

若它是 —

用户定义函数：

The code block for the function is executed, passing it the argument list. The first thing the code block will do is bind the formal parameters to the arguments; this is described in section 函数定义 . When the code block executes a return statement, this specifies the return value of the function call.

内置函数或方法：

结果取决于解释器；见 内置函数 了解内置函数和方法的描述。

类对象：

返回该类的新实例。

类实例方法：

The corresponding user-defined function is called, with an argument list that is one longer than the argument list of the call: the instance becomes the first argument.

类实例：

类必须定义 __call__() 方法；效果与调用该方法的效果相同。

5.4. 幂运算符 ¶

The power operator binds more tightly than unary operators on its left; it binds less tightly than unary operators on its right. The syntax is:

power ::=  primary ["**" u_expr]
					

Thus, in an unparenthesized sequence of power and unary operators, the operators are evaluated from right to left (this does not constrain the evaluation order for the operands): -1**2 产生 -1 .

The power operator has the same semantics as the built-in pow() function, when called with two arguments: it yields its left argument raised to the power of its right argument. The numeric arguments are first converted to a common type. The result type is that of the arguments after coercion.

With mixed operand types, the coercion rules for binary arithmetic operators apply. For int and long int operands, the result has the same type as the operands (after coercion) unless the second argument is negative; in that case, all arguments are converted to float and a float result is delivered. For example, 10**2 返回 100 ，但 10**-2 返回 0.01 . (This last feature was added in Python 2.2. In Python 2.1 and before, if both arguments were of integer types and the second argument was negative, an exception was raised).

引发 0.0 to a negative power results in a ZeroDivisionError . Raising a negative number to a fractional power results in a ValueError .

5.5. 一元算术和按位运算 ¶

All unary arithmetic and bitwise operations have the same priority:

u_expr ::=  power | "-" u_expr | "+" u_expr | "~" u_expr
					

一元 - (minus) operator yields the negation of its numeric argument.

一元 + (plus) operator yields its numeric argument unchanged.

一元 ~ (invert) operator yields the bitwise inversion of its plain or long integer argument. The bitwise inversion of x is defined as -(x+1) . It only applies to integral numbers.

In all three cases, if the argument does not have the proper type, a TypeError 异常被引发。

5.6. 二进制算术运算 ¶

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 / (除法) 和 // (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 异常。

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 等于 0.34 (since 3.14 等于 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 [2] .

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 被替换通过 floor(x/y) or floor(x/y) - 1 [3] .

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, section 字符串格式化操作 .

从 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.

5.7. 移位操作 ¶

移位操作优先级，低于算术运算：

shift_expr ::=  a_expr | shift_expr ( "<<" | ">>" ) a_expr
					

These operators accept plain or long integers as arguments. The arguments are converted to a common type. They shift the first argument to the left or right by the number of bits given by the second argument.

向右移位 n bits is defined as division by pow(2, n) . A left shift by n bits is defined as multiplication with pow(2, n) . Negative shift counts raise a ValueError 异常。

注意

In the current implementation, the right-hand operand is required to be at most sys.maxsize . If the right-hand operand is larger than sys.maxsize an OverflowError 异常被引发。

5.8. 二进制按位运算 ¶

3 按位操作中的每个拥有不同优先级别：

and_expr ::=  shift_expr | and_expr "&" shift_expr
xor_expr ::=  and_expr | xor_expr "^" and_expr
or_expr  ::=  xor_expr | or_expr "|" xor_expr
					

The & operator yields the bitwise AND of its arguments, which must be plain or long integers. The arguments are converted to a common type.

The ^ operator yields the bitwise XOR (exclusive OR) of its arguments, which must be plain or long integers. The arguments are converted to a common type.

The | operator yields the bitwise (inclusive) OR of its arguments, which must be plain or long integers. The arguments are converted to a common type.

5.9. 比较 ¶

不像 C，Python 中的所有比较操作拥有相同优先级，低于任何算术、移位或按位操作。也不像 C，表达式像 a < b < c 拥有数学中的惯例解释：

comparison    ::=  or_expr ( comp_operator or_expr )*
comp_operator ::=  "<" | ">" | "==" | ">=" | "<=" | "<>" | "!="
                   | "is" ["not"] | ["not"] "in"
					

比较产生布尔值： True or False .

比较可以任意连锁，例如， x < y <= z 相当于 x < y and y <= z ，除了 y 只评估 1 次 (但在 2 种情况下， z 根本不评估当 x < y 被发现为 False)。

Formally, if a , b , c , ..., y , z are expressions and op1 , op2 , ..., opN are comparison operators, then a op1 b op2 c ... y opN z 相当于 a op1 b and b op2 c and ... y opN z , except that each expression is evaluated at most once.

注意， a op1 b op2 c doesn’t imply any kind of comparison between a and c , so that, e.g., x < y > z is perfectly legal (though perhaps not pretty).

The forms <> and != are equivalent; for consistency with C, != is preferred; where != is mentioned below <> is also accepted. The <> spelling is considered obsolescent.

运算符 < , > , == , >= , <= ，和 != compare the values of two objects. The objects need not have the same type. If both are numbers, they are converted to a common type. Otherwise, objects of different types always compare unequal, and are ordered consistently but arbitrarily. You can control comparison behavior of objects of non-built-in types by defining a __cmp__ method or rich comparison methods like __gt__ , described in section 特殊方法名称 .

(This unusual definition of comparison was used to simplify the definition of operations like sorting and the in and not in operators. In the future, the comparison rules for objects of different types are likely to change.)

Comparison of objects of the same type depends on the type:

• Numbers are compared arithmetically.

• Strings are compared lexicographically using the numeric equivalents (the result of the built-in function ord() ) of their characters. Unicode and 8-bit strings are fully interoperable in this behavior. [4]

• Tuples and lists are compared lexicographically using comparison of corresponding elements. This means that to compare equal, each element must compare equal and the two sequences must be of the same type and have the same length.

  If not equal, the sequences are ordered the same as their first differing elements. For example, cmp([1,2,x], [1,2,y]) returns the same as cmp(x,y) . If the corresponding element does not exist, the shorter sequence is ordered first (for example, [1,2] < [1,2,3] ).

• Mappings (dictionaries) compare equal if and only if their sorted (key, value) lists compare equal. [5] Outcomes other than equality are resolved consistently, but are not otherwise defined. [6]

• Most other objects of built-in types compare unequal unless they are the same object; the choice whether one object is considered smaller or larger than another one is made arbitrarily but consistently within one execution of a program.

运算符 in and not in test for collection membership. x in s evaluates to true if x is a member of the collection s , and false otherwise. x not in s 返回取反的 x in s . The collection membership test has traditionally been bound to sequences; an object is a member of a collection if the collection is a sequence and contains an element equal to that object. However, it make sense for many other object types to support membership tests without being a sequence. In particular, dictionaries (for keys) and sets support membership testing.

For the list and tuple types, x in y is true if and only if there exists an index i 这样 x == y[i] 为 True。

For the Unicode and string types, x in y 为 True 当且仅当 x is a substring of y . An equivalent test is y.find(x) != -1 . Note, x and y need not be the same type; consequently, u'ab' in 'abc' 将返回 True . Empty strings are always considered to be a substring of any other string, so "" in "abc" 将返回 True .

Changed in version 2.3: 先前， x was required to be a string of length 1 .

For user-defined classes which define the __contains__() 方法， x in y 为 True 当且仅当 y.__contains__(x) 为 True。

For user-defined classes which do not define __contains__() but do define __iter__() , x in y is true if some value z with x == z is produced while iterating over y . If an exception is raised during the iteration, it is as if in raised that exception.

Lastly, the old-style iteration protocol is tried: if a class defines __getitem__() , x in y is true if and only if there is a non-negative integer index i 这样 x == y[i] , and all lower integer indices do not raise IndexError exception. (If any other exception is raised, it is as if in raised that exception).

运算符 not in is defined to have the inverse true value of in .

运算符 is and is not test for object identity: x is y 为 True 当且仅当 x and y are the same object. x is not y yields the inverse truth value. [7]

5.10. 布尔运算 ¶

or_test  ::=  and_test | or_test "or" and_test
and_test ::=  not_test | and_test "and" not_test
not_test ::=  comparison | "not" not_test
					

In the context of Boolean operations, and also when expressions are used by control flow statements, the following values are interpreted as false: False , None , numeric zero of all types, and empty strings and containers (including strings, tuples, lists, dictionaries, sets and frozensets). All other values are interpreted as true. (See the __nonzero__() special method for a way to change this.)

运算符 not 产生 True 若其自变量为 False， False 否则。

表达式 x and y 首先评估 x ；若 x is false, its value is returned; otherwise, y is evaluated and the resulting value is returned.

表达式 x or y 首先评估 x ；若 x is true, its value is returned; otherwise, y is evaluated and the resulting value is returned.

(Note that neither and nor or restrict the value and type they return to False and True , but rather return the last evaluated argument. This is sometimes useful, e.g., if s is a string that should be replaced by a default value if it is empty, the expression s or 'foo' yields the desired value. Because not has to invent a value anyway, it does not bother to return a value of the same type as its argument, so e.g., not 'foo' 产生 False , not '' )。

5.11. 条件表达式 ¶

2.5 版新增。

conditional_expression ::=  or_test ["if" or_test "else" expression]
expression             ::=  conditional_expression | lambda_expr
					

条件表达式 (有时称为三元运算符) 在所有 Python 操作中拥有最低优先级。

表达式 x if C else y 首先评估条件， C ( not x ); if C 为 True， x is evaluated and its value is returned; otherwise, y is evaluated and its value is returned.

见 PEP 308 了解条件表达式的有关更多细节。

5.12. Lambdas ¶

lambda_expr     ::=  "lambda" [parameter_list]: expression
old_lambda_expr ::=  "lambda" [parameter_list]: old_expression
					

Lambda expressions (sometimes called lambda forms) have the same syntactic position as expressions. They are a shorthand to create anonymous functions; the expression lambda arguments: 表达式 yields a function object. The unnamed object behaves like a function object defined with

def name(arguments):
    return expression
					

见章节 函数定义 for the syntax of parameter lists. Note that functions created with lambda expressions cannot contain statements.

5.13. 表达式列表 ¶

expression_list ::=  expression ( "," expression )* [","]
					

An expression list containing at least one comma yields a tuple. The length of the tuple is the number of expressions in the list. The expressions are evaluated from left to right.

The trailing comma is required only to create a single tuple (a.k.a. a singleton ); it is optional in all other cases. A single expression without a trailing comma doesn’t create a tuple, but rather yields the value of that expression. (To create an empty tuple, use an empty pair of parentheses: () )。

5.14. 评估次序 ¶

Python evaluates expressions from left to right. Notice that while evaluating an assignment, the right-hand side is evaluated before the left-hand side.

In the following lines, expressions will be evaluated in the arithmetic order of their suffixes:

expr1, expr2, expr3, expr4
(expr1, expr2, expr3, expr4)
{expr1: expr2, expr3: expr4}
expr1 + expr2 * (expr3 - expr4)
expr1(expr2, expr3, *expr4, **expr5)
expr3, expr4 = expr1, expr2
					

5.15. 运算符优先级 ¶

The following table summarizes the operator precedences in Python, from lowest precedence (least binding) to highest precedence (most binding). Operators in the same box have the same precedence. Unless the syntax is explicitly given, operators are binary. Operators in the same box group left to right (except for comparisons, including tests, which all have the same precedence and chain from left to right — see section 比较 — and exponentiation, which groups from right to left).

运算符	描述
lambda	Lambda 表达式
if – else	条件表达式
or	布尔 OR
and	布尔 AND
not x	布尔 NOT
in , not in , is , is not , < , <= , > , >= , <> , != , ==	Comparisons, including membership tests and identity tests
|	按位 OR
^	按位 XOR
&	按位 AND
<< , >>	Shifts
+ , -	加法和减法
* , / , // , %	Multiplication, division, remainder [8]
+x , -x , ~x	正、负、按位非
**	取幂 [9]
x[index] , x[index:index] , x(arguments...) , x.attribute	Subscription, slicing, call, attribute reference
(expressions...) , [expressions...] , {key: value...} , `expressions...`	Binding or tuple display, list display, dictionary display, string conversion

脚注

[1]	In Python 2.3 and later releases, a list comprehension “leaks” the control variables of each for it contains into the containing scope. However, this behavior is deprecated, and relying on it will not work in Python 3.

[2]

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 . The function math.fmod() 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.

[3]	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 .

[4]

While comparisons between unicode strings make sense at the byte level, they may be counter-intuitive to users. For example, the strings u"\u00C7" and u"\u0043\u0327" compare differently, even though they both represent the same unicode character (LATIN CAPITAL LETTER C WITH CEDILLA). To compare strings in a human recognizable way, compare using unicodedata.normalize() .

[5]	The implementation computes this efficiently, without constructing lists or sorting.

[6]

Earlier versions of Python used lexicographic comparison of the sorted (key, value) lists, but this was very expensive for the common case of comparing for equality. An even earlier version of Python compared dictionaries by identity only, but this caused surprises because people expected to be able to test a dictionary for emptiness by comparing it to {} .

[7]	Due to automatic garbage-collection, free lists, and the dynamic nature of descriptors, you may notice seemingly unusual behaviour in certain uses of the is operator, like those involving comparisons between instance methods, or constants. Check their documentation for more info.

[8]	The % operator is also used for string formatting; the same precedence applies.

[9]	幂运算符 ** binds less tightly than an arithmetic or bitwise unary operator on its right, that is, 2**-1 is 0.5 .