6.2.1。标识符（名称）

作为原子出现的标识符是名称。请参阅 词汇定义的标识符和关键字部分以及命名和绑定文档的命名和绑定部分。

当名称绑定到对象时，对atom的评估会产生该对象。如果未绑定名称，则尝试对其进行评估会引发NameError 异常。

专用名称修改：当在类定义中以文本方式出现的标识符以两个或多个下划线字符开头且不以两个或多个下划线结尾时，它将被视为该类的私有名称。在为其生成代码之前，将私有名称转换为更长的形式。转换将在名称前面插入类名，删除前导下划线并插入单个下划线。例如，名称中__spam出现的标识符Ham将转换为_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
 :: =
comp_for 
 :: = [“async”]“for” “in” [ ]
comp_iter 
 :: =   |
comp_if 
 :: =“if” [ ]
expression
 
comp_for
 
 
target_listor_testcomp_itercomp_forcomp_if
 
expression_nocondcomp_iter

理解包括单个表达式，后跟至少一个 for子句和零个或多个for或if子句。在这种情况下，新容器的元素是通过将每个for或if子句视为一个块，从左到右嵌套，并且每次到达最内部块时评估表达式以产生元素而生成的元素。

但是，除了最左边的for子句中的iterable表达式之外，理解还在一个单独的隐式嵌套作用域中执行。这可确保分配给目标列表中的名称不会“泄漏”到封闭范围中。

最左边for子句中的可迭代表达式直接在封闭范围内计算，然后作为参数传递给隐含嵌套范围。最后一个for子句中的后续子句和任何过滤条件for无法在封闭范围内进行求值，因为它们可能取决于从最左边的可迭代获得的值。例如： 。[x*y for x in range(10) for y in range(x, x+10)]

为了确保理解总是产生适当类型的容器，yield并且在隐式嵌套范围内禁止表达式（在Python 3.7中，这样的表达式 在编译时发出，在Python 3.8+中它们将发出）。yield fromDeprecationWarningSyntaxError

从Python 3.6开始，在函数中， 可以使用子句来迭代异步迭代器。函数中的理解可以包括在前导表达式后面的a 或子句，可以包含附加或 子句，也可以使用表达式。如果理解包含子句或表达式，则称为 异步理解。异步理解可以暂停其出现的协程函数的执行。也可以看看async defasync forasync defforasync forforasync forawaitasyncforawaitPEP 530。

6.2.5。列表显示

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

list_display
 :: =“[”[
starred_list
|
comprehension
]“]”

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

6.2.6。设定显示

集合显示用花括号表示，并且由于缺少分隔键和值的冒号而与字典显示区分开来：

set_display
 :: =“{”（
starred_list
|
comprehension
）“}”

集合显示产生新的可变集合对象，内容由表达式序列或理解指定。当提供以逗号分隔的表达式列表时，将从左到右计算其元素并将其添加到set对象。当提供理解时，该集合由理解产生的元素构成。

无法构造空集{}; 这个文字构造了一个空字典。

6.2.7。字典显示

字典显示是用花括号括起来的可能为空的一系列键/数据对：

dict_display 
 :: =“{”[
key_datum_list
|
dict_comprehension
]“}”
key_datum_list 
 :: =
key_datum
（“，”
key_datum
）* [“，”]
key_datum 
 :: =
expression
“：”
expression
| “**”
dict_comprehension
 :: = “：”
or_expr
 
 
expressionexpression

comp_for字典显示产生新的字典对象。

如果给出了逗号分隔的键/数据对序列，则从左到右计算它们以定义字典的条目：每个键对象用作字典中的键以存储相应的数据。这意味着您可以在键/基准列表中多次指定相同的键，并且该键的最终字典值将是给定的最后一个键。

双星号**表示字典解包。它的操作数必须是映射。每个映射项都添加到新字典中。后面的值替换先前由键/数据对和早期字典解包设置的值。

与list和set comprehensions相反，dict理解需要两个用冒号分隔的表达式，后跟通常的“for”和“if”子句。运行理解时，生成的键和值元素将按照生成的顺序插入到新字典中。

前面的标准类型层次结构一节中列出了对键值类型的限制 。（总而言之，密钥类型应该是可清除的，它排除了所有可变对象。）未检测到重复密钥之间的冲突; 为给定键值存储的最后一个数据（文本上最右边的显示）占优势。

6.2.8。生成器表达式

生成器表达式是括号中的紧凑生成符：

generator_expression
 :: =“（” “）”
expression

comp_for生成器表达式生成一个新的生成器对象。它的语法与理解相同，只是它括在括号中而不是括号或花括号中。

当__next__()为生成器对象调用该方法时，与生成器表达式中使用的变量会被懒惰地评估 （与普通生成器一样）。但是，for会立即计算最左边子句中的可迭代表达式，以便在定义生成器表达式的位置发出由它产生的错误，而不是在检索第一个值的位置发出。最后一个for子句中的后续子句和任何过滤条件 for无法在封闭范围内进行求值，因为它们可能取决于从最左边的可迭代获得的值。例如： 。(x*y for x in range(10) for y inrange(x, x+10))

对于只有一个参数的调用，可以省略括号。有关详细信息，请参阅呼叫部分

为了避免干扰生成器表达式本身的预期操作，yield并且在隐式定义的生成器中禁止表达式（在Python 3.7中，这样的表达式在编译时发出 ，在Python 3.8+中它们将发出 ）。yield fromDeprecationWarningSyntaxError

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

6.2.9。收益表达式

yield_atom 
 :: =“（”
yield_expression
“）”
yield_expression
 :: =“yield”[
expression_list
| “从”
expression
]

yield表达式在定义生成器函数或异步生成器函数时使用，因此只能在函数定义的主体中使用。在函数体中使用yield表达式会导致该函数成为生成器，并且在函数体中使用它会导致该协同函数成为异步生成器。例如：asyncdef

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

由于它们对包含范围的副作用，yield表达式不允许作为用于实现理解和生成器表达式的隐式定义的范围的一部分（在Python 3.7中，这样的表达式DeprecationWarning在编译时发出，在Python 3.8+中它们将发出SyntaxError）。

发电机功能在下面描述的，当异步发电机功能将在节分别描述 异步发电机的功能。

当调用生成器函数时，它返回一个称为生成器的迭代器。然后该生成器控制生成器函数的执行。当调用其中一个生成器的方法时，执行开始。那时，执行进入第一个yield表达式，再次暂停，返回值expression_list到发电机的来电者。通过挂起，我们意味着保留所有本地状态，包括局部变量的当前绑定，指令指针，内部评估堆栈以及任何异常处理的状态。当通过调用生成器的一个方法恢复执行时，该函数可以完全像yield表达式只是另一个外部调用一样。恢复后yield表达式的值取决于恢复执行的方法。如果 __next__()使用（通常通过a for或next()内置），则结果为None。否则，如果send()使用if ，则结果将是传递给该方法的值。

所有这些使得生成器功能与协同程序非常相似; 它们产生多次，它们有多个入口点并且它们的执行可以被暂停。唯一的区别是生成器函数无法控制执行后应该继续执行的位置; 控制器总是转移到发电机的呼叫者。

try构造中的任何位置都允许使用yield表达式。如果生成器在最终确定之前没有恢复（通过达到零引用计数或通过垃圾收集），close()将调用generator-iterator的方法，允许finally执行任何挂起的子句。

当被使用时，它把所供应的表达式作为subiterator。该子转换器生成的所有值都直接传递给当前生成器方法的调用者。传入的任何值和传入的 任何异常都会传递 给底层迭代器（如果它具有适当的方法）。如果不是这种情况， 则会提高或者，而 只是立即提高传递的异常。yield from<expr>send()throw()send()AttributeErrorTypeErrorthrow()

底层迭代器完成后，value 凸起StopIteration实例的属性将成为yield表达式的值。它可以在提升StopIteration时显式设置，也可以在子迭代器是生成器时自动设置 （通过从子生成器返回值）。

版本3.3中已更改：已添加为将控制流委派给子订户。yield from <expr>

当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

主要必须求值为支持属性引用的类型的对象，大多数对象都这样做。然后要求该对象生成名称为标识符的属性。可以通过覆盖该__getattr__()方法来定制该生产。如果此属性不可用，AttributeError则引发异常。否则，生成的对象的类型和值由对象确定。对同一属性引用的多次评估可能产生不同的对象。

6.3.2。订阅

订阅选择序列（字符串，元组或列表）或映射（字典）对象的项：

subscription
 :: =   
primary
“[” 
expression_list
“]”

主要必须评估支持订阅的对象（例如列表或词典）。用户定义的对象可以通过定义__getitem__()方法来支持订阅。

对于内置对象，有两种类型的对象支持订阅：

如果primary是映射，则表达式列表必须求值为其值为映射的键之一的对象，并且预订选择映射中与该键对应的值。（表达式列表是一个元组，除非它只有一个项目。）

如果primary是序列，则表达式列表必须求值为整数或切片（如下一节中所述）。

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

字符串的项目是字符。字符不是单独的数据类型，而是一个恰好一个字符的字符串。

6.3.3。切片

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

切片

:: =   
primary
“[” 
slice_list
“]” 
slice_list 
 :: = 
slice_item
（“，” 
slice_item
）* [“，”] 
slice_item 
 :: = 
expression
| 
proper_slice
 :: = [ ]“：”[ ] [“：”[ ]] 
lower_bound
 :: = 
upper_bound
 :: = 
stride 
 :: = 
proper_slice
 
 
lower_boundupper_boundstrideexpression
expression

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
] | 
positional_arguments
 :: = [“*”] （“，”[“*”] ）* 
starred_and_keywords
 :: =（“*” | ）
keywords_arguments
 
 
expressionexpressionexpressionkeyword_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必须求值为iterable。来自这些迭代的元素被视为它们是附加的位置参数。对于调用 ，如果y计算到序列y1，…，yM，这相当于具有M + 4个位置参数x1，x2， y1，…，yM，x3，x4的调用。f(x1, x2, *y, 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则会引发异常。

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

None除非引发异常，否则调用总是会返回一些值。如何计算此值取决于可调用对象的类型。

如果是-

用户定义的函数：

执行函数的代码块，并将参数列表传递给它。代码块首先要做的是将形式参数绑定到参数; 这在功能定义一节中描述。当代码块执行return语句时，它指定函数调用的返回值。

内置函数或方法：

结果取决于口译员; 有关内置函数和方法的说明，请参阅内置函数。

一个类对象：

返回该类的新实例。

一个类实例方法：

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

一个类实例：

该类必须定义一个__call__()方法; 效果就像调用该方法一样。

6.10.1。价值比较

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

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

由于所有类型都是（直接或间接）子类型object，因此它们继承了默认的比较行为object。类型可以通过实现定制自己的行为比较 丰富的比较方法一样__lt__()，在描述 基本的定制。

相等性比较（==和!=）的默认行为基于对象的标识。因此，具有相同身份的实例的相等比较导致相等，并且具有不同身份的实例的相等性比较导致不等式。这种默认行为的动机是希望所有对象都应该是反身的（即 暗示）。xis yx == y

默认顺序的比较（<，>，<=，和>=）不设置; 企图加油TypeError。这种默认行为的动机是缺乏与平等相似的不变量。

默认相等比较的行为，即具有不同身份的实例总是不相等的，可能与需要具有合理定义的对象值和基于值的相等性的类型形成对比。这些类型需要定制它们的比较行为，事实上，许多内置类型已经完成了。

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

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

  非数字值float('NaN')并且decimal.Decimal('NaN')是特殊的。数字与非数字值的任何有序比较都是错误的。反直觉的含义是非数值不等于它们自身。例如，如果，，，，全是假的。此行为符合IEEE 754。x =float('NaN')3 < xx < 3x == xx != x

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

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

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

• 序列（的实例tuple，list或range）可以仅在每个它们的类型进行比较，与该范围不支持次序比较的限制。这些类型之间的相等比较会导致不平等，并且这些类型之间的排序比较会提高 TypeError。

  序列使用相应元素的比较按字典顺序进行比较，从而强制执行元素的反身性。

  在强制元素的反身性时，集合的比较假定对于集合元素x，始终为真。基于该假设，首先比较元素标识，并且仅针对不同元素执行元素比较。如果比较的元素是自反的，那么这种方法产生与严格元素比较相同的结果。对于非自反元素，结果与严格元素比较的结果不同，并且可能会令人惊讶：例如，非自反的非数字值在列表中使用时会产生以下比较行为：x == x

  >>>
  >>> nan = float('NaN')
  >>> nan is nan
  True
  >>> nan == nan
  False                 <-- the defined non-reflexive behavior of NaN
  >>> [nan] == [nan]
  True                  <-- list enforces reflexivity and tests identity first

   

  内置集合之间的字典比较如下：

  • 对于要比较的两个集合相等，它们必须是相同的类型，具有相同的长度，并且每对相应的元素必须比较相等（例如，因为类型不相同，所以为false）。[1,2] == (1,2)
  • 支持订单比较的集合的排序与它们的第一个不相等的元素相同（例如，具有相同的值）。如果不存在相应的元素，则首先排序较短的集合（例如，为真）。[1,2,x] <= [1,2,y]x <= y[1,2] < [1,2,3]

• dict当且仅当它们具有相等（键，值）对时，映射（实例）才相等。键和值的相等比较强制实现反身性。

  订购比较（<，>，<=和>=）提高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和会员资格测试。 计算结果为，如果X是一个成员小号，和其它。 回归否定。所有内置序列和集合类型都支持这个以及字典，其中测试字典是否具有给定键。对于容器类型，例如list，tuple，set，frozenset，dict或collections.deque，表达式等效于。not inx in sTrueFalsex not in sx in sinx in yany(x is e or x == efor e in y)

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

对于定义__contains__()方法的用户定义类，返回if 返回true值，否则返回true 。x inyTruey.__contains__(x)False

对于不定义用户定义的类__contains__()，但不限定 __iter__()，是，如果某个值与同时迭代产生。如果在迭代期间引发异常，则就好像引发了异常一样。x in yTruezx == zyin

最后，旧式迭代协议尝试：如果一个类定义 __getitem__()，是当且仅当有一个非负整数索引我这样说，并且所有的整数索引不提高例外。（如果引发任何其他异常，就好像提出异常一样）。x in yTruex == y[i]IndexErrorin

运算符被定义为具有倒数真值 。not inin

6.10.3。身份比较

运算符is和对象标识测试：当且仅当x和y是同一个对象时才是真的。使用该函数确定对象标识。 产生反向真值。[4]is notx is yid()x is not y