Generator functions are described below, while asynchronous generator functions are described separately in section
异步生成器函数
.
When a generator function is called, it returns an iterator known as a generator. That generator then controls the execution of the generator function. The execution starts when one of the generator’s methods is called. At that time, the execution proceeds to the first yield expression, where it is suspended again, returning the value of
yield_list
to the generator’s caller, or
None
if
yield_list
is omitted. By suspended, we mean that all local state is retained, including the current bindings of local variables, the instruction pointer, the internal evaluation stack, and the state of any exception handling. When the execution is resumed by calling one of the generator’s methods, the function can proceed exactly as if the yield expression were just another external call. The value of the yield expression after resuming depends on the method which resumed the execution. If
__next__()
is used (typically via either a
for
或
next()
builtin) then the result is
None
. Otherwise, if
send()
is used, then the result will be the value passed in to that method.
All of this makes generator functions quite similar to coroutines; they yield multiple times, they have more than one entry point and their execution can be suspended. The only difference is that a generator function cannot control where the execution should continue after it yields; the control is always transferred to the generator’s caller.
The parentheses may be omitted when the yield expression is the sole expression on the right hand side of an assignment statement.
6.3.
基元
¶
Primaries represent the most tightly bound operations of the language. Their syntax is:
primary ::= atom | attributeref | subscription | slicing | call
6.3.1.
属性引用
¶
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, which most objects do. This object is then asked to produce the attribute whose name is the identifier. The type and value produced is determined by the object. Multiple evaluations of the same attribute reference may yield different objects.
This production can be customized by overriding the
__getattribute__()
method or the
__getattr__()
方法。
__getattribute__()
method is called first and either returns a value or raises
AttributeError
if the attribute is not available.
若
AttributeError
is raised and the object has a
__getattr__()
method, that method is called as a fallback.
6.3.2.
订阅
¶
The subscription of an instance of a
容器类
will generally select an element from the container. The subscription of a
generic class
will generally return a
GenericAlias
对象。
subscription ::= primary "[" flexible_expression_list "]"
When an object is subscripted, the interpreter will evaluate the primary and the expression list.
The primary must evaluate to an object that supports subscription. An object may support subscription through defining one or both of
__getitem__()
and
__class_getitem__()
. When the primary is subscripted, the evaluated result of the expression list will be passed to one of these methods. For more details on when
__class_getitem__
is called instead of
__getitem__
，见
__class_getitem__ versus __getitem__
.
If the expression list contains at least one comma, or if any of the expressions are starred, the expression list will evaluate to a
tuple
containing the items of the expression list. Otherwise, the expression list will evaluate to the value of the list’s sole member.
3.11 版改变：
Expressions in an expression list may be starred. See
PEP 646
.
For built-in objects, there are two types of objects that support subscription via
__getitem__()
:
-
Mappings. If the primary is a
映射
, 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. An example of a builtin mapping class is the
dict
类。
-
Sequences. If the primary is a
sequence
, the expression list must evaluate to an
int
或
slice
(as discussed in the following section). Examples of builtin sequence classes include the
str
,
list
and
tuple
类。
The formal syntax makes no special provision for negative indices in
sequences
. However, built-in sequences all provide a
__getitem__()
method that interprets negative indices by adding the length of the sequence to the index so that, for example,
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). Since the support for negative indices and slicing occurs in the object’s
__getitem__()
method, subclasses overriding this method will need to explicitly add that support.
A
string
is a special kind of sequence whose items are
characters
. A character is not a separate data type but a string of exactly one character.
6.3.3.
切片
¶
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 ::= primary "[" slice_list "]"
slice_list ::= slice_item ("," slice_item)* [","]
slice_item ::= expression | proper_slice
proper_slice ::= [lower_bound] ":" [upper_bound] [ ":" [stride] ]
lower_bound ::= expression
upper_bound ::= expression
stride ::= expression
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).
The semantics for a slicing are as follows. The primary is indexed (using the same
__getitem__()
method as normal subscription) 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 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.
6.3.4.
调用
¶
调用调用可调用对象 (如
function
) 采用可能空的一系列
arguments
:
call ::= primary "(" [argument_list [","] | comprehension] ")"
argument_list ::= positional_arguments ["," starred_and_keywords]
["," keywords_arguments]
| starred_and_keywords ["," keywords_arguments]
| keywords_arguments
positional_arguments ::= positional_item ("," positional_item)*
positional_item ::= assignment_expression | "*" expression
starred_and_keywords ::= ("*" expression | keyword_item)
("," "*" expression | "," keyword_item)*
keywords_arguments ::= (keyword_item | "**" expression)
("," keyword_item | "," "**" expression)*
keyword_item ::= identifier "=" expression
An optional 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 all objects having a
__call__()
method are callable). 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 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
出现在函数调用中，
expression
must evaluate to an
iterable
. Elements from these iterables are treated as if they were additional positional arguments. For the call
f(x1, x2, *y, x3, x4)
，若
y
evaluates to a sequence
y1
, …,
yM
, this is equivalent to a call with M+4 positional arguments
x1
,
x2
,
y1
, …,
yM
,
x3
,
x4
.
A consequence of this is that although the
*expression
syntax may appear
after
explicit keyword arguments, it is processed
before
the keyword arguments (and any
**expression
arguments – 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 <module>
TypeError: f() got multiple values for keyword argument 'a'
>>> f(1, *(2,))
1 2
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 often arise.
若句法
**expression
出现在函数调用中，
expression
必须评估为
映射
, the contents of which are treated as additional keyword arguments. If a parameter matching a key has already been given a value (by an explicit keyword argument, or from another unpacking), a
TypeError
异常被引发。
当
**expression
is used, each key in this mapping must be a string. Each value from the mapping is assigned to the first formal parameter eligible for keyword assignment whose name is equal to the key. A key need not be a Python identifier (e.g.
"max-temp °F"
is acceptable, although it will not match any formal parameter that could be declared). If there is no match to a formal parameter the key-value pair is collected by the
**
parameter, if there is one, or if there is not, a
TypeError
异常被引发。
形式参数使用句法
*identifier
or
**identifier
cannot be used as positional argument slots or as keyword argument names.
3.5 版改变：
Function calls accept any number of
*
and
**
unpackings, positional arguments may follow iterable unpackings (
*
), and keyword arguments may follow dictionary unpackings (
**
). Originally proposed by
PEP 448
.
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. If execution reaches the end of the code block without executing a
return
statement, the return value is
None
.
-
内置函数或方法：
-
结果取决于解释器；见
内置函数
了解内置函数和方法的描述。
-
类对象：
-
返回该类的新实例。
-
类实例方法：
-
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__()
方法；效果与调用该方法的效果相同。
6.5.
幂运算符
¶
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 ::= (await_expr | 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, and the result is of that type.
For int operands, the result has the same type as the operands 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
.
引发
0.0
to a negative power results in a
ZeroDivisionError
. Raising a negative number to a fractional power results in a
complex
number. (In earlier versions it raised a
ValueError
)。
可以定制此操作使用特殊
__pow__()
and
__rpow__()
方法。
6.6.
一元算术和按位运算
¶
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; the operation can be overridden with the
__neg__()
特殊方法。
一元
+
(plus) operator yields its numeric argument unchanged; the operation can be overridden with the
__pos__()
特殊方法。
一元
~
(invert) operator yields the bitwise inversion of its integer argument. The bitwise inversion of
x
is defined as
-(x+1)
. It only applies to integral numbers or to custom objects that override the
__invert__()
特殊方法。
In all three cases, if the argument does not have the proper type, a
TypeError
异常被引发。
6.7.
二进制算术运算
¶
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 "@" m_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 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.
可以定制此操作使用特殊
__mul__()
and
__rmul__()
方法。
The
@
(at) operator is intended to be used for matrix multiplication. No builtin Python types implement this operator.
可以定制此操作使用特殊
__matmul__()
and
__rmatmul__()
方法。
Added in version 3.5.
The
/
(除法) 和
//
(floor division) operators yield the quotient of their arguments. The numeric arguments are first converted to a common type. Division of integers yields a float, while floor division of integers results in an integer; the result is that of mathematical division with the ‘floor’ function applied to the result. Division by zero raises the
ZeroDivisionError
异常。
The division operation can be customized using the special
__truediv__()
and
__rtruediv__()
methods. The floor division operation can be customized using the special
__floordiv__()
and
__rfloordiv__()
方法。
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
.
The floor division and modulo operators are connected by the following identity:
x == (x//y)*y + (x%y)
. Floor division and modulo are also connected with the built-in function
divmod()
:
divmod(x, y) == (x//y,
x%y)
.
.
In addition to performing the modulo operation on numbers, the
%
operator is also overloaded by string objects to perform old-style string formatting (also known as interpolation). The syntax for string formatting is described in the Python Library Reference, section
printf 样式字符串格式化
.
The
modulo
operation can be customized using the special
__mod__()
and
__rmod__()
方法。
The floor division operator, the modulo operator, and the
divmod()
function are not 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 be 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.
可以定制此操作使用特殊
__add__()
and
__radd__()
方法。
The
-
(subtraction) operator yields the difference of its arguments. The numeric arguments are first converted to a common type.
可以定制此操作使用特殊
__sub__()
and
__rsub__()
方法。
6.8.
移位操作
¶
移位操作优先级，低于算术运算：
shift_expr ::= a_expr | shift_expr ("<<" | ">>") a_expr
These operators accept integers as arguments. They shift the first argument to the left or right by the number of bits given by the second argument.
The left shift operation can be customized using the special
__lshift__()
and
__rlshift__()
methods. The right shift operation can be customized using the special
__rshift__()
and
__rrshift__()
方法。
向右移位
n
bits is defined as floor division by
pow(2,n)
. A left shift by
n
bits is defined as multiplication with
pow(2,n)
.
6.9.
二进制按位运算
¶
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 integers or one of them must be a custom object overriding
__and__()
or
__rand__()
特殊方法。
The
^
operator yields the bitwise XOR (exclusive OR) of its arguments, which must be integers or one of them must be a custom object overriding
__xor__()
or
__rxor__()
特殊方法。
The
|
operator yields the bitwise (inclusive) OR of its arguments, which must be integers or one of them must be a custom object overriding
__or__()
or
__ror__()
特殊方法。
6.10.
比较
¶
不像 C，Python 中的所有比较操作拥有相同优先级，低于任何算术、移位或按位操作。也不像 C，表达式像
a < b < c
拥有数学中的惯例解释：
comparison ::= or_expr (comp_operator or_expr)*
comp_operator ::= "<" | ">" | "==" | ">=" | "<=" | "!="
| "is" ["not"] | ["not"] "in"
比较产生布尔值：
True
or
False
。自定义
丰富比较方法
可能返回非布尔值。在这种情况下 Python 将调用
bool()
在布尔上下文中的这种值。
比较可以任意连锁，例如，
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).
6.10.1.
值的比较
¶
运算符
<
,
>
,
==
,
>=
,
<=
，和
!=
比较 2 对象的值。对象不需要拥有相同类型。
章节
对象、值及类型
states that objects have a value (in addition to type and identity). The value of an object is a rather abstract notion in Python: For example, there is no canonical access method for an object’s value. Also, there is no requirement that the value of an object should be constructed in a particular way, e.g. comprised of all its data attributes. Comparison operators implement a particular notion of what the value of an object is. One can think of them as defining the value of an object indirectly, by means of their comparison implementation.
Because all types are (direct or indirect) subtypes of
object
, they inherit the default comparison behavior from
object
. Types can customize their comparison behavior by implementing
丰富比较方法
like
__lt__()
, described in
基本定制
.
The default behavior for equality comparison (
==
and
!=
) is based on the identity of the objects. Hence, equality comparison of instances with the same identity results in equality, and equality comparison of instances with different identities results in inequality. A motivation for this default behavior is the desire that all objects should be reflexive (i.e.
x is y
隐含
x == y
).
默认次序比较 (
<
,
>
,
<=
，和
>=
) is not provided; an attempt raises
TypeError
. A motivation for this default behavior is the lack of a similar invariant as for equality.
The behavior of the default equality comparison, that instances with different identities are always unequal, may be in contrast to what types will need that have a sensible definition of object value and value-based equality. Such types will need to customize their comparison behavior, and in fact, a number of built-in types have done that.
The following list describes the comparison behavior of the most important built-in types.
-
Numbers of built-in numeric types (
数值类型 — 整数、浮点数、复数
) and of the standard library types
fractions.Fraction
and
decimal.Decimal
can be compared within and across their types, with the restriction that complex numbers do not support order comparison. Within the limits of the types involved, they compare mathematically (algorithmically) correct without loss of precision.
非数字值
float('NaN')
and
decimal.Decimal('NaN')
are special. Any ordered comparison of a number to a not-a-number value is false. A counter-intuitive implication is that not-a-number values are not equal to themselves. For example, if
x = float('NaN')
,
3 < x
,
x < 3
and
x == x
are all false, while
x != x
is true. This behavior is compliant with IEEE 754.
-
None
and
NotImplemented
是单例。
PEP 8
建议单例比较应始终采用
is
or
is not
，从不采用相等运算符。
-
二进制序列 (实例化的
bytes
or
bytearray
) can be compared within and across their types. They compare lexicographically using the numeric values of their elements.
-
字符串 (实例化的
str
) compare lexicographically using the numerical Unicode code points (the result of the built-in function
ord()
) of their characters.
Strings and binary sequences cannot be directly compared.
-
Sequences (instances of
tuple
,
list
，或
range
) can be compared only within each of their types, with the restriction that ranges do not support order comparison. Equality comparison across these types results in inequality, and ordering comparison across these types raises
TypeError
.
Sequences compare lexicographically using comparison of corresponding elements. The built-in containers typically assume identical objects are equal to themselves. That lets them bypass equality tests for identical objects to improve performance and to maintain their internal invariants.
Lexicographical comparison between built-in collections works as follows:
-
For two collections to compare equal, they must be of the same type, have the same length, and each pair of corresponding elements must compare equal (for example,
[1,2] == (1,2)
is false because the type is not the same).
-
Collections that support order comparison are ordered the same as their first unequal elements (for example,
[1,2,x] <= [1,2,y]
has the same value as
x <= y
). If a corresponding element does not exist, the shorter collection is ordered first (for example,
[1,2] < [1,2,3]
为 True)。
-
Mappings (instances of
dict
) compare equal if and only if they have equal
(key, value)
pairs. Equality comparison of the keys and values enforces reflexivity.
次序比较 (
<
,
>
,
<=
，和
>=
) 引发
TypeError
.
-
集 (实例化的
set
or
frozenset
) can be compared within and across their types.
They define order comparison operators to mean subset and superset tests. Those relations do not define total orderings (for example, the two sets
{1,2}
and
{2,3}
are not equal, nor subsets of one another, nor supersets of one another). Accordingly, sets are not appropriate arguments for functions which depend on total ordering (for example,
min()
,
max()
，和
sorted()
produce undefined results given a list of sets as inputs).
Comparison of sets enforces reflexivity of its elements.
-
Most other built-in types have no comparison methods implemented, so they inherit the default comparison behavior.
User-defined classes that customize their comparison behavior should follow some consistency rules, if possible:
-
Equality comparison should be reflexive. In other words, identical objects should compare equal:
x is y
隐含
x == y
-
Comparison should be symmetric. In other words, the following expressions should have the same result:
x == y
and
y == x
x != y
and
y != x
x < y
and
y > x
x <= y
and
y >= x
-
Comparison should be transitive. The following (non-exhaustive) examples illustrate that:
x > y and y > z
隐含
x > z
x < y and y <= z
隐含
x < z
-
Inverse comparison should result in the boolean negation. In other words, the following expressions should have the same result:
x == y
and
not x != y
x < y
and
not x >= y
(for total ordering)
x > y
and
not x <= y
(for total ordering)
The last two expressions apply to totally ordered collections (e.g. to sequences, but not to sets or mappings). See also the
total_ordering()
decorator.
-
The
hash()
result should be consistent with equality. Objects that are equal should either have the same hash value, or be marked as unhashable.
Python does not enforce these consistency rules. In fact, the not-a-number values are an example for not following these rules.
6.10.2.
成员资格测试操作
¶
运算符
in
and
not in
用于成员资格测试。
x in
s
评估为
True
if
x
是成员对于
s
，和
False
否则。
x not in s
返回取反的
x in s
. All built-in sequences and set types support this as well as dictionary, for which
in
tests whether the dictionary has a given key. For container types such as list, tuple, set, frozenset, dict, or collections.deque, the expression
x in y
相当于
any(x is e or x == e for e in y)
.
对于字符串和字节类型，
x in y
is
True
if and only if
x
is a substring of
y
. An equivalent test is
y.find(x) != -1
. Empty strings are always considered to be a substring of any other string, so
"" in "abc"
将返回
True
.
For user-defined classes which define the
__contains__()
方法，
x in
y
返回
True
if
y.__contains__(x)
返回 True 值，和
False
否则。
For user-defined classes which do not define
__contains__()
but do define
__iter__()
,
x in y
is
True
if some value
z
, for which the expression
x is z or x == z
is true, 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 is y[i] or x == y[i]
, and no lower integer index raises the
IndexError
exception. (If any other exception is raised, it is as if
in
raised that exception).
运算符
not in
is defined to have the inverse truth value of
in
.
6.10.3.
身份比较
¶
运算符
is
and
is not
测试对象身份：
x
is
y
为 True 当且仅当
x
and
y
are the same object. An Object’s identity is determined using the
id()
函数。
x is not y
yields the inverse truth value.
6.11.
布尔运算
¶
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. User-defined objects can customize their truth value by providing a
__bool__()
方法。
运算符
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 create a new value, it returns a boolean value regardless of the type of its argument (for example,
not 'foo'
produces
False
而不是
''
)。
6.12.
赋值表达式
¶
assignment_expression ::= [identifier ":="] expression
An assignment expression (sometimes also called a “named expression” or “walrus”) assigns an
expression
to an
identifier
, while also returning the value of the
expression
.
One common use case is when handling matched regular expressions:
if matching := pattern.search(data):
do_something(matching)
Or, when processing a file stream in chunks:
while chunk := file.read(9000):
process(chunk)
Assignment expressions must be surrounded by parentheses when used as expression statements and when used as sub-expressions in slicing, conditional, lambda, keyword-argument, and comprehension-if expressions and in
assert
,
with
，和
assignment
statements. In all other places where they can be used, parentheses are not required, including in
if
and
while
语句。
Added in version 3.8:
见
PEP 572
for more details about assignment expressions.
6.13.
条件表达式
¶
conditional_expression ::= or_test ["if" or_test "else" expression]
expression ::= conditional_expression | lambda_expr
条件表达式 (有时称为三元运算符) 在所有 Python 操作中拥有最低优先级。
表达式
x if C else y
首先评估条件，
C
而不是
x
。若
C
为 True，
x
is evaluated and its value is returned; otherwise,
y
is evaluated and its value is returned.
见
PEP 308
了解条件表达式的有关更多细节。
6.14.
Lambda
¶
lambda_expr ::= "lambda" [parameter_list] ":" expression
lambda 表达式 (有时称为 lambda 形式) 用于创建匿名函数。表达式
lambda parameters: expression
产生函数对象。未命名对象的行为像定义函数对象采用：
def <lambda>(parameters):
return expression
见章节
函数定义
了解参数列表的句法。注意：采用 Lambda 表达式创建的函数不可以包含语句 (或注解)。
6.15.
表达式列表
¶
starred_expression ::= ["*"] or_expr
flexible_expression ::= assignment_expression | starred_expression
flexible_expression_list ::= flexible_expression ("," flexible_expression)* [","]
starred_expression_list ::= starred_expression ("," starred_expression)* [","]
expression_list ::= expression ("," expression)* [","]
yield_list ::= expression_list | starred_expression "," [starred_expression_list]
Except when part of a list or set display, 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.
星号
*
表示
可迭代解包
。它的操作数必须是
iterable
. The iterable is expanded into a sequence of items, which are included in the new tuple, list, or set, at the site of the unpacking.
Added in version 3.5:
Iterable unpacking in expression lists, originally proposed by
PEP 448
.
Added in version 3.11:
Any item in an expression list may be starred. See
PEP 646
.
A trailing comma is required only to create a one-item tuple, such as
1,
; 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:
()
)。
6.16.
评估次序
¶
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
6.17.
运算符优先级
¶
The following table summarizes the operator precedence in Python, from highest precedence (most binding) to lowest precedence (least 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 exponentiation and conditional expressions, which group from right to left).
Note that comparisons, membership tests, and identity tests, all have the same precedence and have a left-to-right chaining feature as described in the
比较
章节。
|
运算符
|
描述
|
|
(expressions...)
,
[expressions...]
,
{key: value...}
,
{expressions...}
|
Binding or parenthesized expression, list display, dictionary display, set display
|
|
x[index]
,
x[index:index]
,
x(arguments...)
,
x.attribute
|
Subscription, slicing, call, attribute reference
|
|
await x
|
await 表达式
|
|
**
|
取幂
|
|
+x
,
-x
,
~x
|
正、负、按位非
|
|
*
,
@
,
/
,
//
,
%
|
Multiplication, matrix multiplication, division, floor division, remainder
|
|
+
,
-
|
加法和减法
|
|
<<
,
>>
|
Shifts
|
|
&
|
按位 AND
|
|
^
|
按位 XOR
|
|
|
|
按位 OR
|
|
in
,
not in
,
is
,
is not
,
<
,
<=
,
>
,
>=
,
!=
,
==
|
比较，包括成员资格测试和身份测试
|
|
not x
|
布尔 NOT
|
|
and
|
布尔 AND
|
|
or
|
布尔 OR
|
|
if
–
else
|
条件表达式
|
|
lambda
|
Lambda 表达式
|
|
:=
|
赋值表达式
|
脚注
