6.2.1. 標識符（名稱(chēng)）?

作為原子出現的標識符叫做名稱(chēng)。 請參看 標識符和關(guān)鍵字 一節了解其詞法定義，以及 命名與綁定 獲取有關(guān)命名與綁定的文檔。

當名稱(chēng)被綁定到一個(gè)對象時(shí)，對該原子求值將返回相應對象。 當名稱(chēng)未被綁定時(shí)，嘗試對其求值將引發(fā) NameError 異常。

私有名稱(chēng)轉換: 當以文本形式出現在類(lèi)定義中的一個(gè)標識符以?xún)蓚€(gè)或更多下劃線(xiàn)開(kāi)頭并且不以?xún)蓚€(gè)或更多下劃線(xiàn)結尾，它會(huì )被視為該類(lèi)的 私有名稱(chēng)。 私有名稱(chēng)會(huì )在為其生成代碼之前被轉換為一種更長(cháng)的形式。 轉換時(shí)會(huì )插入類(lèi)名，移除打頭的下劃線(xiàn)再在名稱(chēng)前增加一個(gè)下劃線(xiàn)。 例如，出現在一個(gè)名為 Ham 的類(lèi)中的標識符 __spam 會(huì )被轉換為 _Ham__spam。 這種轉換獨立于標識符所使用的相關(guān)句法。 如果轉換后的名稱(chēng)太長(cháng)（超過(guò) 255 個(gè)字符），可能發(fā)生由具體實(shí)現定義的截斷。 如果類(lèi)名僅由下劃線(xiàn)組成，則不會(huì )進(jìn)行轉換。

6.2.2. 字面值?

Python 支持字符串和字節串字面值，以及幾種數字字面值:

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

對字面值求值將返回一個(gè)該值所對應類(lèi)型的對象（字符串、字節串、整數、浮點(diǎn)數、復數）。 對于浮點(diǎn)數和虛數（復數）的情況，該值可能為近似值。 詳情參見(jiàn) 字面值。

所有字面值都對應與不可變數據類(lèi)型，因此對象標識的重要性不如其實(shí)際值。 多次對具有相同值的字面值求值（不論是發(fā)生在程序文本的相同位置還是不同位置）可能得到相同對象或是具有相同值的不同對象。

6.2.3. 帶圓括號的形式?

帶圓括號的形式是包含在圓括號中的可選表達式列表。

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

帶圓括號的表達式列表將返回該表達式列表所產(chǎn)生的任何東西：如果該列表包含至少一個(gè)逗號，它會(huì )產(chǎn)生一個(gè)元組；否則，它會(huì )產(chǎn)生該表達式列表所對應的單一表達式。

一對內容為空的圓括號將產(chǎn)生一個(gè)空的元組對象。 由于元組是不可變對象，因此適用與字面值相同的規則（即兩次出現的空元組產(chǎn)生的對象可能相同也可能不同）。

請注意元組并不是由圓括號構建，實(shí)際起作用的是逗號操作符。 例外情況是空元組，這時(shí)圓括號 才是 必須的 --- 允許在表達式中使用不帶圓括號的 "空" 會(huì )導致歧義，并會(huì )造成常見(jiàn)輸入錯誤無(wú)法被捕獲。

6.2.4. 列表、集合與字典的顯示?

為了構建列表、集合或字典，Python 提供了名為“顯示”的特殊句法，每個(gè)類(lèi)型各有兩種形式:

• 第一種是顯式地列出容器內容

• 第二種是通過(guò)一組循環(huán)和篩選指令計算出來(lái)，稱(chēng)為 推導式。

推導式的常用句法元素為:

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]

推導式的結構是一個(gè)單獨表達式后面加至少一個(gè) for 子句以及零個(gè)或更多個(gè) for 或 if 子句。 在這種情況下，新容器的元素產(chǎn)生方式是將每個(gè) for 或 if 子句視為一個(gè)代碼塊，按從左至右的順序嵌套，然后每次到達最內層代碼塊時(shí)就對表達式進(jìn)行求值以產(chǎn)生一個(gè)元素。

不過(guò)，除了最左邊 for 子句中的可迭代表達式，推導式是在另一個(gè)隱式嵌套的作用域內執行的。 這能確保賦給目標列表的名稱(chēng)不會(huì )“泄露”到外層的作用域。

最左邊的 for 子句中的可迭代對象表達式會(huì )直接在外層作用域中被求值，然后作為一個(gè)參數被傳給隱式嵌套的作用域。 后續的 for 子句以及最左側 for 子句中的任何篩選條件不能在外層作用域中被求值，因為它們可能依賴(lài)于從最左側可迭代對象中獲得的值。 例如: [x*y for x in range(10) for y in range(x, x+10)]。

為了確保推導式得出的結果總是一個(gè)類(lèi)型正確的容器，在隱式嵌套作用域內禁止使用 yield 和 yield from 表達式。

Since Python 3.6, in an async def function, an async for clause may be used to iterate over a asynchronous iterator. A comprehension in an async def function may consist of either a for or async for clause following the leading expression, may contain additional for or async for clauses, and may also use await expressions. If a comprehension contains either async for clauses or await expressions or other asynchronous comprehensions it is called an asynchronous comprehension. An asynchronous comprehension may suspend the execution of the coroutine function in which it appears. See also PEP 530.

6.2.5. 列表顯示?

列表顯示是一個(gè)用方括號括起來(lái)的可能為空的表達式系列:

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

列表顯示會(huì )產(chǎn)生一個(gè)新的列表對象，其內容通過(guò)一系列表達式或一個(gè)推導式來(lái)指定。 當提供由逗號分隔的一系列表達式時(shí)，其元素會(huì )從左至右被求值并按此順序放入列表對象。 當提供一個(gè)推導式時(shí)，列表會(huì )根據推導式所產(chǎn)生的結果元素進(jìn)行構建。

6.2.6. 集合顯示?

集合顯示是用花括號標明的，與字典顯示的區別在于沒(méi)有冒號分隔的鍵和值:

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

集合顯示會(huì )產(chǎn)生一個(gè)新的可變集合對象，其內容通過(guò)一系列表達式或一個(gè)推導式來(lái)指定。 當提供由逗號分隔的一系列表達式時(shí)，其元素會(huì )從左至右被求值并加入到集合對象。 當提供一個(gè)推導式時(shí)，集合會(huì )根據推導式所產(chǎn)生的結果元素進(jìn)行構建。

空集合不能用 {} 來(lái)構建；該字面值所構建的是一個(gè)空字典。

6.2.7. 字典顯示?

字典顯示是一個(gè)用花括號括起來(lái)的可能為空的鍵/數據對系列:

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

字典顯示會(huì )產(chǎn)生一個(gè)新的字典對象。

如果給出一個(gè)由逗號分隔的鍵/數據對序列，它們會(huì )從左至右被求值以定義字典的條目：每個(gè)鍵對象會(huì )被用作在字典中存放相應數據的鍵。 這意味著(zhù)你可以在鍵/數據對序列中多次指定相同的鍵，最終字典的值將由最后一次給出的鍵決定。

雙星號 ** 表示 字典拆包。 它的操作數必須是一個(gè) mapping。 每個(gè)映射項被會(huì )加入新的字典。 后續的值會(huì )替代先前的鍵/數據對和先前的字典拆包所設置的值。

字典推導式與列表和集合推導式有所不同，它需要以冒號分隔的兩個(gè)表達式，后面帶上標準的 "for" 和 "if" 子句。 當推導式被執行時(shí)，作為結果的鍵和值元素會(huì )按它們的產(chǎn)生順序被加入新的字典。

對鍵取值類(lèi)型的限制已列在之前的 標準類(lèi)型層級結構 一節中。 (總的說(shuō)來(lái)，鍵的類(lèi)型應該為 hashable，這就把所有可變對象都排除在外。) 重復鍵之間的沖突不會(huì )被檢測；指定鍵所保存的最后一個(gè)數據 (即在顯示中排最右邊的文本) 為最終有效數據。

6.2.8. 生成器表達式?

生成器表達式是用圓括號括起來(lái)的緊湊形式生成器標注。

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

生成器表達式會(huì )產(chǎn)生一個(gè)新的生成器對象。 其句法與推導式相同，區別在于它是用圓括號而不是用方括號或花括號括起來(lái)的。

在生成器表達式中使用的變量會(huì )在為生成器對象調用 __next__() 方法的時(shí)候以惰性方式被求值（即與普通生成器相同的方式）。 但是，最左側 for 子句內的可迭代對象是會(huì )被立即求值的，因此它所造成的錯誤會(huì )在生成器表達式被定義時(shí)被檢測到，而不是在獲取第一個(gè)值時(shí)才出錯。 后續的 for 子句以及最左側 for 子句內的任何篩選條件無(wú)法在外層作用域內被求值，因為它們可能會(huì )依賴(lài)于從最左側可迭代對象獲取的值。 例如: (x*y for x in range(10) for y in range(x, x+10)).

圓括號在只附帶一個(gè)參數的調用中可以被省略。 詳情參見(jiàn) 調用 一節。

為了避免干擾到生成器表達式本身的預期操作，禁止在隱式定義的生成器中使用 yield 和 yield from 表達式。

如果生成器表達式包含 async for 子句或 await 表達式，則稱(chēng)為 異步生成器表達式。 異步生成器表達式會(huì )返回一個(gè)新的異步生成器對象，此對象屬于異步迭代器 (參見(jiàn) 異步迭代器)。

6.2.9. yield 表達式?

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

The yield expression is used when defining a generator function or an asynchronous 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 function, and using it in an async def function's body causes that coroutine function to be an asynchronous generator function. For example:

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

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

由于它們會(huì )對外層作用域造成附帶影響，yield 表達式不被允許作為用于實(shí)現推導式和生成器表達式的隱式定義作用域的一部分。

下面是對生成器函數的描述，異步生成器函數會(huì )在 異步生成器函數 一節中單獨介紹。

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

所有這些使生成器函數與協(xié)程非常相似；它們 yield 多次，它們具有多個(gè)入口點(diǎn)，并且它們的執行可以被掛起。唯一的區別是生成器函數不能控制在它在 yield 后交給哪里繼續執行；控制權總是轉移到生成器的調用者。

在 try 結構中的任何位置都允許yield表達式。如果生成器在(因為引用計數到零或是因為被垃圾回收)銷(xiāo)毀之前沒(méi)有恢復執行，將調用生成器-迭代器的 close() 方法. close 方法允許任何掛起的 finally 子句執行。

當使用 yield from <expr> 時(shí)，所提供的表達式必須是一個(gè)可迭代對象。 迭代該可迭代對象所產(chǎn)生的值會(huì )被直接傳遞給當前生成器方法的調用者。 任何通過(guò) send() 傳入的值以及任何通過(guò) throw() 傳入的異常如果有適當的方法則會(huì )被傳給下層迭代器。 如果不是這種情況，那么 send() 將引發(fā) AttributeError 或 TypeError，而 throw() 將立即引發(fā)所轉入的異常。

當下層迭代器完成時(shí)，被引發(fā)的 StopIteration 實(shí)例的 value 屬性會(huì )成為 yield 表達式的值。 它可以在引發(fā) StopIteration 時(shí)被顯式地設置，也可以在子迭代器是一個(gè)生成器時(shí)自動(dòng)地設置（通過(guò)從子生成器返回一個(gè)值）。

在 3.3 版更改: 添加 yield from <expr> 以委托控制流給一個(gè)子迭代器。

當yield表達式是賦值語(yǔ)句右側的唯一表達式時(shí)，括號可以省略。

>>> 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. 屬性引用?

屬性引用是后面帶有一個(gè)句點(diǎn)加一個(gè)名稱(chēng)的原型:

attributeref ::=  primary "." identifier

此原型必須求值為一個(gè)支持屬性引用的類(lèi)型的對象，多數對象都支持屬性引用。 隨后該對象會(huì )被要求產(chǎn)生以指定標識符為名稱(chēng)的屬性。 這個(gè)產(chǎn)生過(guò)程可通過(guò)重載 __getattr__() 方法來(lái)自定義。 如果這個(gè)屬性不可用，則將引發(fā) AttributeError 異常。 否則的話(huà)，所產(chǎn)生對象的類(lèi)型和值會(huì )根據該對象來(lái)確定。 對同一屬性引用的多次求值可能產(chǎn)生不同的對象。

6.3.2. 抽取?

The subscription of an instance of a container class will generally select an element from the container. The subscription of a generic class will generally return a GenericAlias object.

subscription ::=  primary "[" 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__, see __class_getitem__ versus __getitem__.

If the expression list contains at least one comma, it 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.

For built-in objects, there are two types of objects that support subscription via __getitem__():

1. Mappings. If the primary is a mapping, 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 class.

2. Sequences. If the primary is a sequence, the expression list must evaluate to an int or a slice (as discussed in the following section). Examples of builtin sequence classes include the str, list and tuple classes.

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. 切片?

切片就是在序列對象（字符串、元組或列表）中選擇某個(gè)范圍內的項。 切片可被用作表達式以及賦值或 del 語(yǔ)句的目標。 切片的句法如下:

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

此處的正式句法中存在一點(diǎn)歧義：任何形似表達式列表的東西同樣也會(huì )形似切片列表，因此任何抽取操作也可以被解析為切片。 為了不使句法更加復雜，于是通過(guò)定義將此情況解析為抽取優(yōu)先于解析為切片來(lái)消除這種歧義（切片列表未包含正確的切片就屬于此情況）。

切片的語(yǔ)義如下所述。 元型通過(guò)一個(gè)根據下面的切片列表來(lái)構造的鍵進(jìn)行索引（與普通抽取一樣使用 __getitem__() 方法）。 如果切片列表包含至少一個(gè)逗號，則鍵將是一個(gè)包含切片項轉換的元組；否則的話(huà)，鍵將是單個(gè)切片項的轉換。 切片項如為一個(gè)表達式，則其轉換就是該表達式。 一個(gè)正確切片的轉換就是一個(gè)切片對象（參見(jiàn) 標準類(lèi)型層級結構 一節），該對象的 start, stop 和 step 屬性將分別為表達式所給出的下界、上界和步長(cháng)值，省略的表達式將用 None 來(lái)替換。

6.3.4. 調用?

所謂調用就是附帶可能為空的一系列 參數 來(lái)執行一個(gè)可調用對象 (例如 function):

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

一個(gè)可選項為在位置和關(guān)鍵字參數后加上逗號而不影響語(yǔ)義。

此原型必須求值為一個(gè)可調用對象（用戶(hù)定義的函數，內置函數，內置對象的方法，類(lèi)對象，類(lèi)實(shí)例的方法以及任何具有 __call__() 方法的對象都是可調用對象）。 所有參數表達式將在嘗試調用前被求值。 請參閱 函數定義 一節了解正式的 parameter 列表句法。

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.

如果存在比正式參數空位多的位置參數，將會(huì )引發(fā) TypeError 異常，除非有一個(gè)正式參數使用了 *identifier 句法；在此情況下，該正式參數將接受一個(gè)包含了多余位置參數的元組（如果沒(méi)有多余位置參數則為一個(gè)空元組）。

如果任何關(guān)鍵字參數沒(méi)有與之對應的正式參數名稱(chēng)，將會(huì )引發(fā) TypeError 異常，除非有一個(gè)正式參數使用了 **identifier 句法，該正式參數將接受一個(gè)包含了多余關(guān)鍵字參數的字典（使用關(guān)鍵字作為鍵而參數值作為與鍵對應的值），如果沒(méi)有多余關(guān)鍵字參數則為一個(gè)（新的）空字典。

如果函數調用中出現了 *expression 句法，expression 必須求值為一個(gè) iterable。 來(lái)自該可迭代對象的元素會(huì )被當作是額外的位置參數。 對于 f(x1, x2, *y, x3, x4) 調用，如果 y 求值為一個(gè)序列 y1, ..., yM，則它就等價(jià)于一個(gè)帶有 M+4 個(gè)位置參數 x1, x2, y1, ..., yM, x3, x4 的調用。

這樣做的一個(gè)后果是雖然 *expression 句法可能出現于顯式的關(guān)鍵字參數 之后，但它會(huì )在關(guān)鍵字參數（以及任何 **expression 參數 -- 見(jiàn)下文） 之前 被處理。 因此:

>>> 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 必須求值為一個(gè) mapping，其內容會(huì )被當作是額外的關(guān)鍵字參數。 如果一個(gè)關(guān)鍵字已存在（作為顯式關(guān)鍵字參數，或來(lái)自另一個(gè)拆包），則將引發(fā) TypeError 異常。

使用 *identifier 或 **identifier 句法的正式參數不能被用作位置參數空位或關(guān)鍵字參數名稱(chēng)。

除非引發(fā)了異常，調用總是會(huì )有返回值，返回值也可能為 None。 返回值的計算方式取決于可調用對象的類(lèi)型。

如果類(lèi)型為---

用戶(hù)自定義函數:

函數的代碼塊會(huì )被執行，并向其傳入參數列表。 代碼塊所做的第一件事是將正式形參綁定到對應參數；相關(guān)描述參見(jiàn) 函數定義 一節。 當代碼塊執行 return 語(yǔ)句時(shí)，由其指定函數調用的返回值。

內置函數或方法:

具體結果依賴(lài)于解釋器；有關(guān)內置函數和方法的描述參見(jiàn) 內置函數。

類(lèi)對象:

返回該類(lèi)的一個(gè)新實(shí)例。

類(lèi)實(shí)例方法:

調用相應的用戶(hù)自定義函數，向其傳入的參數列表會(huì )比調用的參數列表多一項：該實(shí)例將成為第一個(gè)參數。

類(lèi)實(shí)例:

該類(lèi)必須定義有 __call__() 方法；作用效果將等價(jià)于調用該方法。

6.10.1. 值比較?

運算符 <, >, ==, >=, <= 和 != 將比較兩個(gè)對象的值。 兩個(gè)對象不要求為相同類(lèi)型。

對象、值與類(lèi)型 一章已說(shuō)明對象都有相應的值（還有類(lèi)型和標識號）。 對象值在 Python 中是一個(gè)相當抽象的概念：例如，對象值并沒(méi)有一個(gè)規范的訪(fǎng)問(wèn)方法。 而且，對象值并不要求具有特定的構建方式，例如由其全部數據屬性組成等。 比較運算符實(shí)現了一個(gè)特定的對象值概念。 人們可以認為這是通過(guò)實(shí)現對象比較間接地定義了對象值。

由于所有類(lèi)型都是 object 的（直接或間接）子類(lèi)型，它們都從 object 繼承了默認的比較行為。 類(lèi)型可以通過(guò)實(shí)現 豐富比較方法 例如 __lt__() 來(lái)定義自己的比較行為，詳情參見(jiàn) 基本定制。

默認的一致性比較 (== 和 !=) 是基于對象的標識號。 因此，具有相同標識號的實(shí)例一致性比較結果為相等，具有不同標識號的實(shí)例一致性比較結果為不等。 規定這種默認行為的動(dòng)機是希望所有對象都應該是自反射的 (即 x is y 就意味著(zhù) x == y)。

次序比較 (<, >, <= 和 >=) 默認沒(méi)有提供；如果嘗試比較會(huì )引發(fā) TypeError。 規定這種默認行為的原因是缺少與一致性比較類(lèi)似的固定值。

按照默認的一致性比較行為，具有不同標識號的實(shí)例總是不相等，這可能不適合某些對象值需要有合理定義并有基于值的一致性的類(lèi)型。 這樣的類(lèi)型需要定制自己的比較行為，實(shí)際上，許多內置類(lèi)型都是這樣做的。

以下列表描述了最主要內置類(lèi)型的比較行為。

• 內置數值類(lèi)型 (數字類(lèi)型 --- int, float, complex) 以及標準庫類(lèi)型 fractions.Fraction 和 decimal.Decimal 可進(jìn)行類(lèi)型內部和跨類(lèi)型的比較，例外限制是復數不支持次序比較。 在類(lèi)型相關(guān)的限制以?xún)?，它們?huì )按數學(xué)（算法）規則正確進(jìn)行比較且不會(huì )有精度損失。

  非數字值 float('NaN') 和 decimal.Decimal('NaN') 屬于特例。 任何數字與非數字值的排序比較均返回假值。 還有一個(gè)反直覺(jué)的結果是非數字值不等于其自身。 舉例來(lái)說(shuō)，如果 x = float('NaN') 則 3 < x, x < 3 和 x == x 均為假值，而 x != x 則為真值。 此行為是遵循 IEEE 754 標準的。

• None 和 NotImplemented 都是單例對象。 PEP 8 建議單例對象的比較應當總是通過(guò) is 或 is not 而不是等于運算符來(lái)進(jìn)行。

• 二進(jìn)制碼序列 (bytes 或 bytearray 的實(shí)例) 可進(jìn)行類(lèi)型內部和跨類(lèi)型的比較。 它們使用其元素的數字值按字典順序進(jìn)行比較。

• 字符串 (str 的實(shí)例) 使用其字符的 Unicode 碼位數字值 (內置函數 ord() 的結果) 按字典順序進(jìn)行比較。 3

  字符串和二進(jìn)制碼序列不能直接比較。

• 序列 (tuple, list 或 range 的實(shí)例) 只可進(jìn)行類(lèi)型內部的比較，range 還有一個(gè)限制是不支持次序比較。 以上對象的跨類(lèi)型一致性比較結果將是不相等，跨類(lèi)型次序比較將引發(fā) TypeError。

  序列比較是按字典序對相應元素進(jìn)行逐個(gè)比較。 內置容器通常設定同一對象與其自身是相等的。 這使得它們能跳過(guò)同一對象的相等性檢測以提升運行效率并保持它們的內部不變性。

  內置多項集間的字典序比較規則如下:

  • 兩個(gè)多項集若要相等，它們必須為相同類(lèi)型、相同長(cháng)度，并且每對相應的元素都必須相等（例如，[1,2] == (1,2) 為假值，因為類(lèi)型不同）。

  • 對于支持次序比較的多項集，排序與其第一個(gè)不相等元素的排序相同（例如 [1,2,x] <= [1,2,y] 的值與``x <= y`` 相同）。 如果對應元素不存在，較短的多項集排序在前（例如 [1,2] < [1,2,3] 為真值）。

• 兩個(gè)映射 (dict 的實(shí)例) 若要相等，必須當且僅當它們具有相同的 (鍵, 值) 對。 鍵和值的一致性比較強制規定自反射性。

  次序比較 (<, >, <= 和 >=) 將引發(fā) TypeError。

• 集合 (set 或 frozenset 的實(shí)例) 可進(jìn)行類(lèi)型內部和跨類(lèi)型的比較。

  它們將比較運算符定義為子集和超集檢測。 這類(lèi)關(guān)系沒(méi)有定義完全排序（例如 {1,2} 和 {2,3} 兩個(gè)集合不相等，即不為彼此的子集，也不為彼此的超集。 相應地，集合不適宜作為依賴(lài)于完全排序的函數的參數（例如如果給出一個(gè)集合列表作為 min(), max() 和 sorted() 的輸入將產(chǎn)生未定義的結果）。

  集合的比較強制規定其元素的自反射性。

• 大多數其他內置類(lèi)型沒(méi)有實(shí)現比較方法，因此它們會(huì )繼承默認的比較行為。

在可能的情況下，用戶(hù)定義類(lèi)在定制其比較行為時(shí)應當遵循一些一致性規則:

• 相等比較應該是自反射的。 換句話(huà)說(shuō)，相同的對象比較時(shí)應該相等:

  x is y 意味著(zhù) x == y

• 比較應該是對稱(chēng)的。 換句話(huà)說(shuō)，下列表達式應該有相同的結果:

  x == y 和 y == x

  x != y 和 y != x

  x < y 和 y > x

  x <= y 和 y >= x

• 比較應該是可傳遞的。 下列（簡(jiǎn)要的）例子顯示了這一點(diǎn):

  x > y and y > z 意味著(zhù) x > z

  x < y and y <= z 意味著(zhù) x < z

• 反向比較應該導致布爾值取反。 換句話(huà)說(shuō)，下列表達式應該有相同的結果:

  x == y 和 not x != y

  x < y 和 not x >= y (對于完全排序)

  x > y 和 not x <= y (對于完全排序)

  最后兩個(gè)表達式適用于完全排序的多項集（即序列而非集合或映射）。 另請參閱 total_ordering() 裝飾器。

• hash() 的結果應該與是否相等一致。 相等的對象應該或者具有相同的哈希值，或者標記為不可哈希。

Python 并不強制要求這些一致性規則。 實(shí)際上，非數字值就是一個(gè)不遵循這些規則的例子。

6.10.2. 成員檢測運算?

運算符 in 和 not in 用于成員檢測。 如果 x 是 s 的成員則 x in s 求值為 True，否則為 False。 x not in s 返回 x in s 取反后的值。 所有內置序列和集合類(lèi)型以及字典都支持此運算，對于字典來(lái)說(shuō) in 檢測其是否有給定的鍵。 對于 list, tuple, set, frozenset, dict 或 collections.deque 這樣的容器類(lèi)型，表達式 x in y 等價(jià)于 any(x is e or x == e for e in y)。

對于字符串和字節串類(lèi)型來(lái)說(shuō)，當且僅當 x 是 y 的子串時(shí) x in y 為 True。 一個(gè)等價(jià)的檢測是 y.find(x) != -1。 空字符串總是被視為任何其他字符串的子串，因此 "" in "abc" 將返回 True。

對于定義了 __contains__() 方法的用戶(hù)自定義類(lèi)來(lái)說(shuō)，如果 y.__contains__(x) 返回真值則 x in y 返回 True，否則返回 False。

對于未定義 __contains__() 但定義了 __iter__() 的用戶(hù)自定義類(lèi)來(lái)說(shuō)，如果在對 y 進(jìn)行迭代時(shí)產(chǎn)生了值 z 使得表達式 x is z or x == z 為真，則 x in y 為 True。 如果在迭代期間引發(fā)了異常，則等同于 in 引發(fā)了該異常。

最后將會(huì )嘗試舊式的迭代協(xié)議：如果一個(gè)類(lèi)定義了 __getitem__()，則當且僅當存在非負整數索引號 i 使得 x is y[i] or x == y[i] 并且沒(méi)有更小的索引號引發(fā) IndexError 異常時(shí) x in y 為 True。 （如果引發(fā)了任何其他異常，則等同于 in 引發(fā)了該異常）。

運算符 not in 被定義為具有與 in 相反的邏輯值。

6.10.3. 標識號比較?

運算符 is 和 is not 用于檢測對象的標識號：當且僅當 x 和 y 是同一對象時(shí) x is y 為真。 一個(gè)對象的標識號可使用 id() 函數來(lái)確定。 x is not y 會(huì )產(chǎn)生相反的邏輯值。 4