6.2.1. Identifiers (Names)¶

一个以原子出现的标识符是一个名称。词法定义请参看标识符和关键字小节，名称和绑定的文档请参看名称和绑定小节。

当名称绑定到一个对象上时，对该原子的求值将产生那个对象。When a name is not bound, an attempt to evaluate it raises a NameError exception.

Private name mangling: 当出现在类定义中的标识符以两个或多个下划线字符开始且不是以两个或多个下划线结束，它被认为是那个类的私有名称。在为它们生成代码之前，私有名称被转换为更长的形式。该转换在名称的前面插入类的名称，前导的下滑线被删除并插入一个单一的下划线。例如，出现在类Ham中的标识符__spam将被转换成_Ham__spam。这种转换与标识符使用的语法上下文无关。如果转换后的名称过长（超过255个字符），将可能发生与具体实现有关的截断。如果类的名称只由下划线组成，则不会转换。

6.2.2. Literals¶

Python supports string and bytes literals and various numeric literals:

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

Evaluation of a literal yields an object of the given type (string, bytes, integer, floating point number, complex number) with the given value. 在浮点数和虚数（复数）情况下，可能只是近似值。详细信息参见字面值一节。

All literals correspond to immutable data types, and hence the object’s identity is less important than its value. 多次计算具有相同值的字面值（无论是程序文本中相同的出现还是不同的出现）得到的既可能是同一个对象也可能是具有相同值的不同对象。

6.2.3. Parenthesized forms¶

圆括号式是包含在圆括号中的一个可选表达式序列：

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

A parenthesized expression list yields whatever that expression list yields: if the list contains at least one comma, it yields a tuple; 否则，它产生组成表达式序列的那个单一表达式。

空的圆括号对产生空的元组对象；Since tuples are immutable, the rules for literals apply (i.e., two occurrences of the empty tuple may or may not yield the same object).

注意元组不是通过圆括号而是逗号操作符形成。The exception is the empty tuple, for which parentheses are required — allowing unparenthesized “nothing” in expressions would cause ambiguities and allow common typos to pass uncaught.

6.2.4. Displays for lists, sets and dictionaries¶

For constructing a list, a set or a dictionary Python provides special syntax called “displays”, each of them in two flavors:

• 容器的内容被显式地列出，或者
• 它们通过一系列循环和过滤指令计算得到，这种方式叫做推导式。

推导式常见的语法元素为：

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]

推导式由一个单一的表达式后面跟随至少一个for子句加上零个或多个for或者if子句。在这种情况下，新的列表的元素是由for或者if子句块产生，这些子句块从左向右嵌套，且当到达最内层的代码块时对表达式求值以产生一个列表元素。

Note that the comprehension is executed in a separate scope, so names assigned to in the target list don’t “leak” into the enclosing scope.

6.2.5. List displays¶

列表表示式是在方括号中的可以为空的一系列表达式：

list_display ::=  "[" [expression_list | comprehension] "]"

A list display yields a new list object, the contents being specified by either a list of expressions or a comprehension. 当提供的是一个逗号分隔的表达式序列时，对它的元素从左向右求值并按此顺序放入列表对象中。When a comprehension is supplied, the list is constructed from the elements resulting from the comprehension.

6.2.6. Set displays¶

集合表示式通过花括号表明，与字典表示式的区别是缺少冒号分隔的键和值：

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

集合表示式产生一个新的可变集合对象，它的内容可以通过一个表达式序列或者一个推导式指定。当提供的是一个逗号分隔的表达式序列时，将从左向右计算它的元素并添加到集合对象中。当提供的是一个推导式时，集合根据推导式产生的元素构造。

不可以用{}构造一个空集合；该字面值构造一个空的字典。

6.2.7. Dictionary displays¶

字典表示式是在花括号中的可以为空的一系列键/值对。

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

字典表示式产生一个新的字典对象。

如果给出逗号分隔的键/值对序列，将从左向右对它们求值以定义字典中项：用每个键对象作为字典的键并存储对应的值。这意味着你可以在键/值序列中多次指定相同的键，但是该键最终对应的字典的值将是最后给出的那个值。

字典推导式，与列表和集合推导式相比，需要两个被冒号分隔的表达式并在后面跟随通常的“for”和“if”子句。当推导执行时，产生的键和值以它们生成的顺序插入到新的字典中。

键的类型的限制在前面的标准类型的层次一节中有列出。（简要地讲，键的类型应该是可哈希的，即排除所有可变的对象。）重复的键之间的冲突不会被检测到；一个给定的键的最后的值（表示式中最右边的值）将获胜。

6.2.8. Generator expressions¶

生成器表达式是在圆括号中的一个简洁的生成器符号：

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

生成器表达式产生一个新的生成器对象。它的语法与推导式相同，只是它位于圆括号而不是方括号或花括号中。

Variables used in the generator expression are evaluated lazily when the __next__() method is called for the generator object (in the same fashion as normal generators). 但是，最左边的for子句会立即计算，所以它产生的错误可以在生成器表达式代码中的任何其它可能的错误之前发现。随后的for子句不可以立即计算因为它们可能依赖于前面的for循环。例如：(x*y for x in range(10) for y in bar(x))。

圆括号对于只有一个参数的调用可以省略。See section Calls for details.

6.2.9. Yield expressions¶

yield_atom       ::=  "(" yield_expression ")"
yield_expression ::=  "yield" [expression_list | "from" expression]

The yield expression is only used when defining a generator function and thus can only be used in the body of a function definition. Using a yield expression in a function’s body causes that function to be a generator.

当调用生成器函数时，它返回一个称为生成器的迭代器。That generator then controls the execution of the generator function. 当调用生成器的其中一个方法时，执行开始。At that time, the execution proceeds to the first yield expression, where it is suspended again, returning the value of expression_list to the generator’s caller. 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 or the next() builtin) then the result is None. Otherwise, if send() is used, then the result will be the value passed in to that method.

所有这些使得生成器函数与协程非常类似；它们可以yield多次，它们有多个入口点且它们的执行可以挂起。The only difference is that a generator function cannot control where the execution should continue after it yields; 控制始终被转让给生成器的调用者。

Yield expressions are allowed anywhere in a try construct. If the generator is not resumed before it is finalized (by reaching a zero reference count or by being garbage collected), the generator-iterator’s close() method will be called, allowing any pending finally clauses to execute.

When yield from <expr> is used, it treats the supplied expression as a subiterator. All values produced by that subiterator are passed directly to the caller of the current generator’s methods. Any values passed in with send() and any exceptions passed in with throw() are passed to the underlying iterator if it has the appropriate methods. If this is not the case, then send() will raise AttributeError or TypeError, while throw() will just raise the passed in exception immediately.

When the underlying iterator is complete, the value attribute of the raised StopIteration instance becomes the value of the yield expression. It can be either set explicitly when raising StopIteration, or automatically when the sub-iterator is a generator (by returning a value from the sub-generator).

Changed in version 3.3: Added yield from <expr> to delegate control flow to a subiterator

The parentheses may be omitted when the yield expression is the sole expression on the right hand side of an assignment statement.

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

6.3.1. Attribute references¶

属性引用是一个初级操作，后面跟随一个句号和一个名称：

attributeref ::=  primary "." identifier

The primary must evaluate to an object of a type that supports attribute references, which most objects do. 接着该对象被要求生成名称为identifier的属性。This production can be customized by overriding the __getattr__() method. If this attribute is not available, the exception AttributeError is raised. 否则，生成的对象的类型和值取决于该对象。对相同属性的多次求值可能产生不同的对象。

6.3.2. Subscriptions¶

下标选择序列（字符串、元组或列表）或者映射（字典）对象的一个元素：

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

The primary must evaluate to an object that supports subscription (lists or dictionaries for example). User-defined objects can support subscription by defining a __getitem__() method.

For built-in objects, there are two types of objects that support subscription:

如果primary是一个映射，那么expression_list必须是一个对象，其值为映射的一个键，该下标选择映射中对应于该键的值。（expression_list是一个元组除非它只有一个元素。）

If the primary is a sequence, the expression (list) must evaluate to an integer or a slice (as discussed in the following section).

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 x[-1] selects the last item of x). 结果值必须是一个小于序列元素个数的非负整数，下标操作选择索引为该值的元素（从零开始计数）。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.

字符串的元素为字符。字符不是一个单独的数据类型而是只有一个字符的字符串。

6.3.3. Slicings¶

切片选择序列对象（例如，字符串、元组和列表）中一个范围内的元素。切片可以用作表达式或者作为赋值和del语句的目标。切片的语法：

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

这里的形式语法有歧义：expession_list看上去也像slice_list，所以任何下标也可以解释为切片。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. 如果slice_list包含至少一个逗号，则键是一个包含slice_item转换的元组；否则，long_slice作为键。slice_item是一个表达式时，转换就是那个表达式。The conversion of a proper slice is a slice object (see section The standard type hierarchy) 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. Calls¶

调用是指用一个可以为空的参数序列调用一个可调用对象（例如，一个函数）：

call                 ::=  primary "(" [argument_list [","] | comprehension] ")"
argument_list        ::=  positional_arguments ["," keyword_arguments]
                            ["," "*" expression] ["," keyword_arguments]
                            ["," "**" expression]
                          | keyword_arguments ["," "*" expression]
                            ["," keyword_arguments] ["," "**" expression]
                          | "*" expression ["," keyword_arguments] ["," "**" expression]
                          | "**" expression
positional_arguments ::=  expression ("," expression)*
keyword_arguments    ::=  keyword_item ("," keyword_item)*
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). 所有的参数表达式都将在调用发生之前求值。关于形式参数列表的语法请参考函数的定义一节。

如果存在关键字参数，它们首先被转换为位置参数，如下所述。首先，创建一个没有填充的空位序列用于形参。如果有N个位置参数，则它们被放置在前N个空位中。下一步，对于每个关键字参数，用标识符决定对应的位置（如果标识符与第一个形参的名称相同，则使用第一个位置，以此类推）。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). 当处理完所有的参数时，仍然没有填充的位置将用来自函数定义的对应默认值填充。（默认值只在函数定义时计算一次；因此，用于默认值的可变对象例如列表或字典将被所有没有指定对应位置参数值的调用共享；通常应该避免这点。）If there are any unfilled slots for which no default value is specified, a TypeError exception is raised. 否则，使用这些填满的位置作为调用的参数序列。

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; 在这种情况下，该形参接收一个包含多余位置参数的元组（如果没有多余的位置参数则为空元组）。

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; 在这种情况下，该形参接收一个包含多余的关键字参数的字典（使用关键字作为键，参数值作为对应的值），如果没有多余的关键字参数则为一个（新的）空字典。

如果*expression语法出现在函数调用中，那么expression必须是一个可迭代器。来自该可迭代器的元素被当作额外的位置参数；如果位置参数为x1, …, xN且expression求值为一个序列y1, …, yM，那么它等同于用M+N个位置参数x1, …, xN, y1, …, yM的调用。

这种方式的后果是虽然*expression可以出现在某些关键字参数之后，但是它将在关键字参数（以及**expression参数–见下文）之前处理。所以：

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

关键字参数和*expression语法都在同一个调用中使用很不常见，所以实践中这种困惑不会出现。

如果**expression语法出现在函数调用中，那么expression必须是一个映射，它的内容将被当作额外的关键字参数。In the case of a keyword appearing in both expression and as an explicit keyword argument, a TypeError exception is raised.

使用*identifier或者**identifier语法的形参不可以作为位置参数的槽位或者关键字参数的名称使用。

A call always returns some value, possibly None, unless it raises an exception. 该值如何计算取决于可调用对象的类型。

如果它是—

一个用户定义的函数：

该函数的代码块将被执行，并将参数列表传递给它。代码块所做的第一件事是将绑实参与参数定；这在函数的定义一节有讲述。当代码块执行一条return时，它表示该函数调用的返回值。

一个内建的函数或方法：

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

一个类对象：

返回该类的一个新的实例。

一个类实例的方法：

调用对应的用户自定义的函数，参数列表比调用的参数列表多一个元素：实例成为第一个参数。

一个类实例：

该类必须定义一个__call__()方法；效果和调用该方法一样。