6. 表达式¶

6.2.1. 标识符（名称）¶

作为原子的标识符是名称。有关词法定义，请参见 标识符和关键字 部分，有关命名和绑定的文档，请参见 命名和绑定 部分。

当名称绑定到对象时，对原子的求值会产生该对象。当名称未绑定时，尝试对其求值会引发 NameError 异常。

6.2.2. 字面值¶

Python 支持字符串和字节字面值以及各种数字字面值

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

对字面值的求值会产生具有给定值的给定类型（字符串、字节、整数、浮点数、复数）的对象。在浮点数和虚数（复数）字面值的情况下，该值可能是近似值。有关详细信息，请参见 字面值 部分。

所有字面值都对应于不可变的数据类型，因此对象的标识不如其值重要。对具有相同值的字面值（程序文本中的相同出现或不同的出现）进行多次求值可能会获得相同的对象或具有相同值的不同对象。

6.2.3. 圆括号形式¶

带括号的形式是一个用括号括起来的可选表达式列表

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

带括号的表达式列表会产生该表达式列表产生的任何内容：如果列表至少包含一个逗号，则会产生一个元组；否则，它会产生构成表达式列表的单个表达式。

一对空括号会产生一个空元组对象。由于元组是不可变的，因此适用与字面值相同的规则（即，空元组的两次出现可能产生也可能不产生相同的对象）。

请注意，元组不是由括号形成的，而是由逗号的使用形成的。例外情况是空元组，对于空元组，确实需要括号 — 允许在表达式中使用不带括号的“nothing”会导致歧义，并允许常见的拼写错误被忽略。

6.2.4. 列表、集合和字典的显示¶

为了构造列表、集合或字典，Python 提供了特殊的语法，称为“显示”，它们各有两种风格

• 要么明确列出容器内容，要么

• 它们是通过一组循环和过滤指令计算出来的，称为推导式。

推导式的常见语法元素为

comprehension ::=  assignment_expression comp_for
comp_for      ::=  ["async"] "for" target_list "in" or_test [comp_iter]
comp_iter     ::=  comp_for | comp_if
comp_if       ::=  "if" or_test [comp_iter]

推导式由一个表达式组成，后跟至少一个 for 子句和零个或多个 for 或 if 子句。在这种情况下，新容器的元素是那些通过将每个 for 或 if 子句视为块（从左到右嵌套）并求值表达式来产生元素的，每次到达最内层块时都会产生一个元素。

但是，除了最左侧 for 子句中的可迭代表达式外，推导式是在单独的隐式嵌套作用域中执行的。这确保了在目标列表中赋值的名称不会“泄漏”到封闭作用域中。

最左侧 for 子句中的可迭代表达式会在外层作用域中直接求值，然后作为参数传递给隐式嵌套的作用域。后续的 for 子句以及最左侧 for 子句中的任何过滤条件都不能在外层作用域中求值，因为它们可能依赖于从最左侧可迭代对象获得的值。例如：[x*y for x in range(10) for y in range(x, x+10)]。

为了确保推导式始终产生适当类型的容器，禁止在隐式嵌套作用域中使用 yield 和 yield from 表达式。

自 Python 3.6 起，在 async def 函数中，可以使用 async for 子句来迭代 异步迭代器。 async def 函数中的推导式可以包含前导表达式之后的 for 或 async for 子句，还可以包含额外的 for 或 async for 子句，并且还可以使用 await 表达式。

如果推导式包含 async for 子句，或者除了最左侧 for 子句中的可迭代表达式之外，在任何位置包含 await 表达式或其他异步推导式，则称为异步推导式。异步推导式可能会挂起其所在的协程函数的执行。另请参阅 PEP 530。

6.2.5. 列表显示¶

列表显示是用方括号括起来的可能为空的一系列表达式。

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

列表显示会产生一个新的列表对象，其内容由一系列表达式或推导式指定。当提供以逗号分隔的表达式列表时，其元素将从左到右求值，并按该顺序放入列表对象中。当提供推导式时，列表将根据推导式产生的元素构建。

6.2.6. 集合显示¶

集合显示用花括号表示，并通过缺少分隔键和值的分号来与字典显示区分开。

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

集合显示会产生一个新的可变集合对象，其内容由一系列表达式或推导式指定。当提供以逗号分隔的表达式列表时，其元素将从左到右求值并添加到集合对象中。当提供推导式时，集合将根据推导式产生的元素构建。

不能使用 {} 构造空集合；此字面量构造一个空字典。

6.2.7. 字典显示¶

字典显示是用花括号括起来的可能为空的一系列字典项（键/值对）。

dict_display       ::=  "{" [dict_item_list | dict_comprehension] "}"
dict_item_list     ::=  dict_item ("," dict_item)* [","]
dict_item          ::=  expression ":" expression | "**" or_expr
dict_comprehension ::=  expression ":" expression comp_for

字典显示会产生一个新的字典对象。

如果给出以逗号分隔的字典项序列，则会从左到右求值，以定义字典的条目：每个键对象都用作字典中的键来存储相应的值。这意味着您可以在字典项列表中多次指定相同的键，并且该键的最终字典值将是最后给出的值。

双星号 ** 表示字典解包。它的操作数必须是 映射。每个映射项都会添加到新字典中。后面的值会替换较早的字典项和较早的字典解包设置的值。

与列表和集合推导式相反，字典推导式需要两个用冒号分隔的表达式，后跟通常的“for”和“if”子句。当推导式运行时，生成的键和值元素会按照它们产生的顺序插入新字典中。

键值的类型限制在前面的 标准类型层次结构 一节中列出。（总而言之，键类型应该是 可哈希的，这排除了所有可变对象。）不会检测重复键之间的冲突；给定键值的最后一个值（在显示中按文本最右边的值）优先。

6.2.8. 生成器表达式¶

生成器表达式是括号中紧凑的生成器表示法。

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

生成器表达式会产生一个新的生成器对象。它的语法与推导式相同，只不过它用括号而不是方括号或花括号括起来。

当为生成器对象调用 __next__() 方法时，生成器表达式中使用的变量会延迟求值（与普通生成器的方式相同）。但是，最左侧 for 子句中的可迭代表达式会立即求值，因此它产生的错误将在定义生成器表达式的点发出，而不是在检索第一个值的点发出。后续的 for 子句以及最左侧 for 子句中的任何过滤条件都不能在外层作用域中求值，因为它们可能依赖于从最左侧可迭代对象获得的值。例如：(x*y for x in range(10) for y in range(x, x+10))。

在只有一个参数的调用中，可以省略括号。有关详细信息，请参阅 调用 一节。

为了避免干扰生成器表达式本身的操作，禁止在隐式定义的生成器中使用 yield 和 yield from 表达式。

如果生成器表达式包含 async for 子句或 await 表达式，则称为异步生成器表达式。异步生成器表达式返回一个新的异步生成器对象，该对象是一个异步迭代器（请参阅 异步迭代器）。

6.2.9. Yield 表达式¶

yield_atom       ::=  "(" yield_expression ")"
yield_from       ::=  "yield" "from" expression
yield_expression ::=  "yield" yield_list | yield_from

当定义生成器函数或异步生成器函数时，会使用 yield 表达式，因此只能在函数定义的函数体中使用。在函数体中使用 yield 表达式会导致该函数成为生成器函数，而在async def函数的函数体中使用则会导致该协程函数成为异步生成器函数。例如：

def gen():  # defines a generator function
    yield 123

async def agen(): # defines an asynchronous generator function
    yield 123

由于 `yield` 表达式会对包含它的作用域产生副作用，因此不允许将其作为隐式定义的作用域的一部分，而这些隐式定义的作用域用于实现推导式和生成器表达式。

生成器函数将在下面介绍，而异步生成器函数将在异步生成器函数章节中单独介绍。

当调用生成器函数时，它会返回一个称为生成器的迭代器。然后，该生成器控制生成器函数的执行。当调用生成器的方法之一时，执行开始。此时，执行会进行到第一个 yield 表达式，在那里它再次被挂起，将yield_list的值返回给生成器的调用者，如果省略了yield_list，则返回None。所谓挂起，是指保留所有局部状态，包括局部变量的当前绑定、指令指针、内部求值堆栈以及任何异常处理的状态。当通过调用生成器的方法之一恢复执行时，该函数可以像 yield 表达式只是另一个外部调用一样继续执行。恢复后，yield 表达式的值取决于恢复执行的方法。如果使用__next__()（通常通过for 或内置的next()函数），则结果为None。否则，如果使用send()，则结果将是传递给该方法的值。

所有这些都使得生成器函数与协程非常相似；它们多次 yield，它们有多个入口点，并且它们的执行可以被挂起。唯一的区别是生成器函数无法控制在 yield 后应该在哪里继续执行；控制权总是转移到生成器的调用者。

yield 表达式允许在try结构中的任何位置使用。如果生成器在完成（通过达到零引用计数或被垃圾回收）之前没有恢复，则会调用生成器迭代器的close()方法，允许执行任何挂起的finally子句。

当使用yield from <expr>时，提供的表达式必须是可迭代的。通过迭代该可迭代对象产生的值将直接传递给当前生成器方法的调用者。任何使用send()传入的值和任何使用throw()传入的异常，如果底层迭代器具有适当的方法，则会传递给该迭代器。如果不是这种情况，那么send()将引发AttributeError或TypeError，而throw()将立即引发传入的异常。

当底层迭代器完成时，引发的StopIteration实例的value属性将成为 yield 表达式的值。它可以在引发StopIteration时显式设置，或者当子迭代器是生成器时自动设置（通过从子生成器返回一个值）。

当 yield 表达式是赋值语句右侧的唯一表达式时，可以省略括号。

>>> 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. 属性引用¶

属性引用是一个基本要素，后跟一个句点和一个名称

attributeref ::=  primary "." identifier

基本要素必须求值为支持属性引用的类型的对象，大多数对象都支持属性引用。然后，会要求此对象生成名称为标识符的属性。产生的类型和值由对象决定。多次求值相同的属性引用可能会产生不同的对象。

可以通过重写 __getattribute__() 方法或 __getattr__() 方法来自定义此生成。首先调用 __getattribute__() 方法，如果该属性不可用，则返回一个值或引发 AttributeError。

如果引发了 AttributeError，并且对象具有 __getattr__() 方法，则将调用该方法作为回退。

6.3.2. 下标¶

容器类实例的下标通常会从容器中选择一个元素。 泛型类的下标通常会返回一个 GenericAlias 对象。

subscription ::=  primary "[" flexible_expression_list "]"

当一个对象被下标时，解释器将求值基本要素和表达式列表。

基本要素必须求值为支持下标的对象。对象可以通过定义 __getitem__() 和 __class_getitem__() 中的一个或两个来支持下标。当下标基本要素时，表达式列表的求值结果将被传递给这些方法之一。有关何时调用 __class_getitem__ 而不是 __getitem__ 的更多详细信息，请参阅 __class_getitem__ 与 __getitem__。

如果表达式列表包含至少一个逗号，或者如果任何表达式带有星号，则表达式列表将求值为一个包含表达式列表项的 tuple。否则，表达式列表将求值为列表唯一成员的值。

对于内置对象，有两种类型的对象通过 __getitem__() 支持下标

1. 映射。如果基本要素是一个 映射，则表达式列表必须求值为一个其值是映射的键之一的对象，并且下标会选择映射中与该键对应的值。内置映射类的一个示例是 dict 类。

2. 序列。如果主要对象是序列，则表达式列表必须求值为一个int或一个slice（如下节所述）。内置序列类的示例包括str、list和tuple类。

正式语法没有为序列中的负索引做出特殊规定。但是，所有内置序列都提供一个__getitem__()方法，该方法通过将序列的长度添加到索引来解释负索引，例如，x[-1]选择x的最后一项。结果值必须是一个非负整数，小于序列中的项目数，并且下标选择索引值为该值的项目（从零开始计数）。由于对负索引和切片的支持发生在对象的__getitem__()方法中，因此重写此方法的子类将需要显式添加该支持。

字符串是一种特殊的序列，其项是字符。字符不是单独的数据类型，而是一个恰好包含一个字符的字符串。

6.3.3. 切片¶

切片选择序列对象（例如，字符串、元组或列表）中的一系列项。切片可以用作表达式或赋值中的目标，或者用作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

这里的正式语法存在歧义：任何看起来像表达式列表的东西也看起来像切片列表，因此任何下标都可以解释为切片。为了避免进一步使语法复杂化，我们定义在这种情况下，解释为下标的优先级高于解释为切片的优先级（如果切片列表不包含任何适当的切片，则属于这种情况）。

切片的语义如下。主要对象使用从切片列表构造的键进行索引（使用与普通下标相同的__getitem__()方法）。如果切片列表至少包含一个逗号，则键是一个元组，其中包含切片项的转换；否则，单独的切片项的转换就是键。作为表达式的切片项的转换是该表达式。适当的切片的转换是一个切片对象（请参阅标准类型层次结构部分），其start、stop和step属性分别是作为下界、上界和步长给定的表达式的值，如果缺少表达式则替换为None。

6.3.4. 调用¶

调用使用一个可能为空的参数序列调用一个可调用对象（例如，一个函数）

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

位置参数和关键字参数之后可以有一个可选的尾随逗号，但不会影响语义。

主要对象必须求值为一个可调用对象（用户定义的函数、内置函数、内置对象的方法、类对象、类实例的方法以及所有具有__call__()方法的对象都是可调用的）。在尝试调用之前，将评估所有参数表达式。有关形式参数列表的语法，请参阅函数定义部分。

如果存在关键字参数，它们首先被转换为位置参数，如下所示。首先，为形式参数创建一个未填充的槽列表。如果有 N 个位置参数，则将它们放置在前 N 个槽中。接下来，对于每个关键字参数，使用标识符来确定相应的槽（如果标识符与第一个形式参数名称相同，则使用第一个槽，依此类推）。如果该槽已被填充，则会引发TypeError异常。否则，该参数将被放置在该槽中，填充它（即使表达式为None，也会填充该槽）。当所有参数都已处理完毕后，仍未填充的槽将使用函数定义中的相应默认值填充。（默认值是在定义函数时计算一次；因此，用作默认值的可变对象（如列表或字典）将被所有不为相应槽指定参数值的调用共享；通常应避免这种情况。）如果有任何未填充的槽没有指定默认值，则会引发TypeError异常。否则，填充的槽列表将用作调用的参数列表。

如果位置参数的数量多于形式参数槽的数量，则会引发TypeError异常，除非存在使用语法*identifier的形式参数；在这种情况下，该形式参数接收一个包含多余的位置参数的元组（如果没有多余的位置参数，则接收一个空元组）。

如果任何关键字参数与形式参数名称不对应，则会引发TypeError异常，除非存在使用语法**identifier的形式参数；在这种情况下，该形式参数接收一个字典，其中包含多余的关键字参数（使用关键字作为键，参数值作为对应的值），如果没有多余的关键字参数，则接收一个（新的）空字典。

如果语法*expression出现在函数调用中，则expression必须求值为一个可迭代对象。来自这些可迭代对象的元素被视为附加的位置参数。对于调用f(x1, x2, *y, x3, x4)，如果y求值为一个序列y1，…，yM，则等效于调用 M+4 个位置参数 x1, x2, y1, …, yM, x3, x4。

这样做的结果是，尽管*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 <module>
TypeError: f() got multiple values for keyword argument 'a'
>>> f(1, *(2,))
1 2

在同一个调用中同时使用关键字参数和*expression语法是不寻常的，因此实际上这种混淆通常不会发生。

如果语法**expression出现在函数调用中，则expression必须求值为一个映射，其内容被视为附加的关键字参数。如果与键匹配的参数已被赋予一个值（通过显式关键字参数或来自另一个解包），则会引发TypeError异常。

当使用**expression时，此映射中的每个键都必须是一个字符串。映射中的每个值都将分配给第一个符合关键字赋值条件的形式参数，其名称与该键相同。键不必是 Python 标识符（例如，"max-temp °F"是可以接受的，尽管它不会与任何可以声明的形式参数匹配）。如果没有与形式参数匹配的项，则键值对将由**参数收集（如果存在），如果不存在，则会引发TypeError异常。

使用 *identifier 或 **identifier 语法的形式参数不能用作位置参数槽或关键字参数名称。

除非引发异常，否则调用总是返回某个值，可能是 None。此值的计算方式取决于可调用对象的类型。

如果它是—

用户定义的函数

将执行该函数的代码块，并传递参数列表。代码块要做的第一件事是将形式参数绑定到实参；这在 函数定义 部分中进行了描述。当代码块执行 return 语句时，这将指定函数调用的返回值。如果执行到达代码块末尾而没有执行 return 语句，则返回值为 None。

内置函数或方法

结果取决于解释器；有关内置函数和方法的描述，请参阅 内置函数。

类对象

返回该类的新实例。

类实例方法

调用相应的用户定义函数，其参数列表比调用的参数列表长一个：实例成为第一个参数。

类实例

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

6.10.1. 值比较¶

运算符 <、>、==、>=、<= 和 != 比较两个对象的值。对象不需要具有相同的类型。

第 对象、值和类型 章指出，对象具有一个值（除了类型和标识）。对象的值在 Python 中是一个相当抽象的概念：例如，没有用于访问对象值的规范方法。此外，不要求以特定方式构造对象的值，例如由其所有数据属性组成。比较运算符实现了对象值的特定概念。可以将它们视为通过它们的比较实现间接地定义对象的值。

因为所有类型都是 object 的（直接或间接）子类型，它们从 object 继承默认的比较行为。类型可以通过实现 *富比较方法*（如 __lt__()）来自定义它们的比较行为，如 基本自定义 中所述。

相等比较（== 和 !=）的默认行为基于对象的标识。因此，具有相同标识的实例的相等比较导致相等，而具有不同标识的实例的相等比较导致不相等。这种默认行为的一个动机是希望所有对象都是自反的（即，x is y 意味着 x == y）。

不提供默认的顺序比较（<、>、<= 和 >=）；尝试会引发 TypeError。这种默认行为的一个动机是缺少与相等类似的不可变量。

默认相等比较的行为（即具有不同标识的实例始终不相等）可能与那些需要对对象值和基于值的相等性进行合理定义的类型相反。此类类型将需要自定义其比较行为，事实上，许多内置类型已经这样做了。

以下列表描述了最重要的内置类型的比较行为。

• 内置数值类型（数值类型 — int、float、complex）以及标准库类型 fractions.Fraction 和 decimal.Decimal 的数值可以在它们类型内部以及跨类型之间进行比较，但复数不支持顺序比较。在所涉及类型的限制范围内，它们的比较在数学上（算法上）是正确的，且不会损失精度。

  非数字值 float('NaN') 和 decimal.Decimal('NaN') 是特殊的。任何数字与非数字值的有序比较都为假。一个反直觉的含义是非数字值不等于自身。例如，如果 x = float('NaN')，则 3 < x、x < 3 和 x == x 均为假，而 x != x 为真。此行为符合 IEEE 754 标准。

• None 和 NotImplemented 是单例对象。 PEP 8 建议对单例对象的比较应始终使用 is 或 is not，绝不使用相等运算符。

• 二进制序列（bytes 或 bytearray 的实例）可以在其类型内部和跨类型之间进行比较。 它们使用元素的数值按字典顺序进行比较。

• 字符串（str 的实例）使用其字符的数字 Unicode 代码点（内置函数 ord() 的结果）按字典顺序进行比较。 [3]

  字符串和二进制序列不能直接比较。

• 序列（tuple、list 或 range 的实例）只能在各自类型内部进行比较，但范围不支持顺序比较。跨这些类型进行相等比较会导致不相等，跨这些类型进行排序比较会引发 TypeError。

  序列使用对应元素的比较按字典顺序进行比较。内置容器通常假设相同的对象等于它们自身。这允许它们绕过对相同对象的相等性测试，以提高性能并维护其内部不变性。

  内置集合之间的字典顺序比较的工作方式如下：

  • 要使两个集合比较相等，它们必须是相同的类型，具有相同的长度，并且每对对应的元素必须比较相等（例如，[1,2] == (1,2) 为假，因为类型不同）。

  • 支持顺序比较的集合按其第一个不相等的元素的顺序排序（例如，[1,2,x] <= [1,2,y] 的值与 x <= y 的值相同）。如果对应的元素不存在，则较短的集合排序靠前（例如，[1,2] < [1,2,3] 为真）。

• 映射（dict 的实例）当且仅当它们具有相等的 (key, value) 对时才比较相等。键和值的相等性比较会强制执行自反性。

  顺序比较（<、>、<= 和 >=）会引发 TypeError。

• 集合（set 或 frozenset 的实例）可以在其类型内部和跨类型之间进行比较。

  它们定义顺序比较运算符来表示子集和超集测试。 这些关系不定义全序（例如，两个集合 {1,2} 和 {2,3} 不相等，也不是彼此的子集，也不是彼此的超集）。因此，集合不适合作为依赖于全序的函数的参数（例如，min()、max() 和 sorted() 在给定集合列表作为输入时会产生未定义的结果）。

  集合的比较会强制执行其元素的自反性。

• 大多数其他内置类型没有实现比较方法，因此它们继承默认的比较行为。

自定义其比较行为的用户定义类应尽可能遵循一些一致性规则：

• 相等比较应该是自反的。 换句话说，相同的对象应该比较相等。

  x is y 意味着 x == y

• 比较应该是对称的。 换句话说，以下表达式应该具有相同的结果：

  x == y 和 y == x

  x != y 和 y != x

  x < y 和 y > x

  x <= y 和 y >= x

• 比较应该是传递的。以下（非详尽的）示例说明了这一点：

  x > y and y > z 意味着 x > z

  x < y and y <= z 意味着 x < z

• 反向比较应导致布尔否定。 换句话说，以下表达式应该具有相同的结果：

  x == y 和 not x != y

  x < y 和 not x >= y（对于全序）

  x > y 和 not x <= y（对于全序）

  最后两个表达式适用于完全排序的集合（例如，序列，但不适用于集合或映射）。另请参阅 total_ordering() 装饰器。

• hash() 的结果应与相等性一致。相等的对象应具有相同的哈希值，或者被标记为不可哈希。

Python 不会强制执行这些一致性规则。实际上，非数字值就是一个不遵循这些规则的例子。

6.10.2. 成员检测操作¶

运算符 in 和 not in 用于测试成员关系。x in s 的求值结果为 True，如果 x 是 s 的成员，否则为 False。x not in s 返回 x in s 的否定。所有内置的序列和集合类型都支持此操作，字典也支持，其中 in 测试字典是否具有给定的键。对于诸如列表、元组、集合、frozenset、字典或 collections.deque 之类的容器类型，表达式 x in y 等效于 any(x is e or x == e for e in y)。

对于字符串和字节类型，当且仅当 x 是 y 的子字符串时，x in y 为 True。等效的测试是 y.find(x) != -1。空字符串始终被认为是任何其他字符串的子字符串，因此 "" in "abc" 将返回 True。

对于定义了 __contains__() 方法的用户定义类，如果 y.__contains__(x) 返回 true 值，则 x in y 返回 True，否则返回 False。

对于未定义 __contains__() 但定义了 __iter__() 的用户定义类，如果迭代 y 时生成了某个值 z，并且表达式 x is z or x == z 为 true，则 x in y 为 True。如果在迭代过程中引发异常，则如同 in 引发了该异常。

最后，尝试旧式迭代协议：如果一个类定义了 __getitem__()，当且仅当存在一个非负整数索引 i，使得 x is y[i] or x == y[i]，并且没有更小的整数索引引发 IndexError 异常时，x in y 为 True。（如果引发任何其他异常，则如同 in 引发了该异常）。

运算符 not in 的定义为具有与 in 相反的真值。

6.10.3. 身份比较¶

运算符 is 和 is not 测试对象的身份：当且仅当 x 和 y 是同一个对象时，x is y 为 true。对象的身份使用 id() 函数确定。x is not y 产生相反的真值。[4]