6. 表达式¶

6.2.1. 标识符（名称）¶

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

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

私有名称混淆： 当在类定义中文本出现的标识符以两个或多个下划线字符开头，并且不以两个或多个下划线字符结尾时，它被认为是该类的私有名称。私有名称在生成代码之前将被转换为更长的形式。转换会在名称前面插入类名，删除前导下划线并插入一个下划线。例如，在名为 Ham 的类中出现的标识符 __spam 将被转换为 _Ham__spam。此转换独立于标识符使用的语法上下文。如果转换后的名称过长（超过 255 个字符），则可能会发生实现定义的截断。如果类名仅由下划线组成，则不会进行转换。

6.2.2. 字面量¶

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

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

字面量的求值会生成给定类型（字符串、字节、整数、浮点数、复数）的具有给定值的某个对象。对于浮点数和虚数（复数）字面量，该值可能被近似。有关详细信息，请参见部分 字面量。

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

6.2.3. 带括号的形式¶

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

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

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

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

请注意，元组不是由括号形成的，而是由逗号形成的。唯一的例外是空元组，它需要括号——在表达式中允许不带括号的“空”会导致歧义，并允许常见的拼写错误不被捕获。

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 子句或 await 表达式或其他异步推导式，则称为 异步推导式。异步推导式可能会挂起它所出现的协程函数的执行。另请参见 PEP 530。

6.2.5. 列表显示¶

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

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

列表显示生成一个新的列表对象，其内容由表达式列表或推导式指定。当提供逗号分隔的表达式列表时，其元素从左到右进行计算，并按该顺序放入列表对象中。当提供推导式时，列表由推导式产生的元素构成。

6.2.6. 集合显示¶

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

set_display ::=  "{" (starred_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" expression_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 表达式，在那里它将再次暂停，将expression_list的值返回给生成器的调用者，或者如果省略了expression_list，则返回None。通过暂停，我们的意思是所有局部状态都将保留，包括局部变量的当前绑定、指令指针、内部评估堆栈以及任何异常处理的状态。当通过调用生成器方法之一来恢复执行时，该函数可以继续执行，就好像 yield 表达式只是另一个外部调用一样。恢复后 yield 表达式的值取决于恢复执行的方法。如果使用__next__()（通常通过for或内置的next()），则结果为None。否则，如果使用send()，则结果将是传递给该方法的值。

所有这些使得生成器函数非常类似于协程；它们多次产生，它们具有多个入口点，并且它们的执行可以暂停。唯一的区别是生成器函数无法控制在产生后执行应继续的位置；控制始终转移到生成器的调用者。

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 "[" 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 语句时，这将指定函数调用的返回值。

内置函数或方法

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

类对象

将返回该类的新的实例。

类实例方法

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

类实例

类必须定义一个 __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 如果 x 是 s 的成员，则计算结果为 True，否则为 False。 x not in s 返回 x in s 的否定。所有内置序列和集合类型都支持此功能，以及字典，对于字典，in 测试字典是否具有给定的键。对于容器类型，如列表、元组、集合、冻结集合、字典或 collections.deque，表达式 x in y 等效于 any(x is e or x == e for e in y)。

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

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

对于未定义 __contains__() 但定义了 __iter__() 的用户自定义类，x in y 当在迭代 y 时产生一些值 z，对于该值表达式 x is z or x == z 为真时，结果为 True。如果在迭代期间引发异常，则相当于 in 抛出了该异常。

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

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

6.10.3. 身份比较¶

运算符 is 和 is not 用于测试对象的标识：x is y 当且仅当 x 和 y 是同一个对象时为真。对象的标识使用 id() 函数确定。 x is not y 返回相反的真值。 [4]