6. 表達(dá)式?

6.2.1. 標(biāo)識符（名稱）?

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

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

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

6.2.2. 字面值?

Python 支持字符串和字節(jié)串字面值，以及幾種數(shù)字字面值:

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

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

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

6.2.3. 帶圓括號的形式?

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

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

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

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

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

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

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

• 第一種是顯式地列出容器內(nèi)容

• 第二種是通過一組循環(huán)和篩選指令計(jì)算出來，稱為 推導(dǎo)式。

推導(dǎo)式的常用句法元素為:

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]

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

不過，除了最左邊 for 子句中的可迭代表達(dá)式，推導(dǎo)式是在另一個隱式嵌套的作用域內(nèi)執(zhí)行的。 這能確保賦給目標(biāo)列表的名稱不會“泄露”到外層的作用域。

最左邊的 for 子句中的可迭代對象表達(dá)式會直接在外層作用域中被求值，然后作為一個參數(shù)被傳給隱式嵌套的作用域。 后續(xù)的 for 子句以及最左側(cè) for 子句中的任何篩選條件不能在外層作用域中被求值，因?yàn)樗鼈兛赡芤蕾囉趶淖钭髠?cè)可迭代對象中獲得的值。 例如: [x*y for x in range(10) for y in range(x, x+10)]。

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

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. 列表顯示?

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

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

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

6.2.6. 集合顯示?

集合顯示是用花括號標(biāo)明的，與字典顯示的區(qū)別在于沒有冒號分隔的鍵和值:

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

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

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

6.2.7. 字典顯示?

字典顯示是一個用花括號括起來的可能為空的鍵/數(shù)據(jù)對系列:

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

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

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

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

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

對鍵取值類型的限制已列在之前的 標(biāo)準(zhǔn)類型層級結(jié)構(gòu) 一節(jié)中。 (總的說來，鍵的類型應(yīng)該為 hashable，這就把所有可變對象都排除在外。) 重復(fù)鍵之間的沖突不會被檢測；指定鍵所保存的最后一個數(shù)據(jù) (即在顯示中排最右邊的文本) 為最終有效數(shù)據(jù)。

6.2.8. 生成器表達(dá)式?

生成器表達(dá)式是用圓括號括起來的緊湊形式生成器標(biāo)注。

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

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

在生成器表達(dá)式中使用的變量會在為生成器對象調(diào)用 __next__() 方法的時候以惰性方式被求值（即與普通生成器相同的方式）。 但是，最左側(cè) for 子句內(nèi)的可迭代對象是會被立即求值的，因此它所造成的錯誤會在生成器表達(dá)式被定義時被檢測到，而不是在獲取第一個值時才出錯。 后續(xù)的 for 子句以及最左側(cè) for 子句內(nèi)的任何篩選條件無法在外層作用域內(nèi)被求值，因?yàn)樗鼈兛赡軙蕾囉趶淖钭髠?cè)可迭代對象獲取的值。 例如: (x*y for x in range(10) for y in range(x, x+10)).

圓括號在只附帶一個參數(shù)的調(diào)用中可以被省略。 詳情參見 調(diào)用 一節(jié)。

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

如果生成器表達(dá)式包含 async for 子句或 await 表達(dá)式，則稱為 異步生成器表達(dá)式。 異步生成器表達(dá)式會返回一個新的異步生成器對象，此對象屬于異步迭代器 (參見 異步迭代器)。

6.2.9. yield 表達(dá)式?

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

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

下面是對生成器函數(shù)的描述，異步生成器函數(shù)會在 異步生成器函數(shù) 一節(jié)中單獨(dú)介紹。

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.

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

在 try 結(jié)構(gòu)中的任何位置都允許yield表達(dá)式。如果生成器在(因?yàn)橐糜?jì)數(shù)到零或是因?yàn)楸焕厥?銷毀之前沒有恢復(fù)執(zhí)行，將調(diào)用生成器-迭代器的 close() 方法. close 方法允許任何掛起的 finally 子句執(zhí)行。

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

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

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

當(dāng)yield表達(dá)式是賦值語句右側(cè)的唯一表達(dá)式時，括號可以省略。

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

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

attributeref ::=  primary "." identifier

此原型必須求值為一個支持屬性引用的類型的對象，多數(shù)對象都支持屬性引用。 隨后該對象會被要求產(chǎn)生以指定標(biāo)識符為名稱的屬性。 這個產(chǎn)生過程可通過重載 __getattr__() 方法來自定義。 如果這個屬性不可用，則將引發(fā) AttributeError 異常。 否則的話，所產(chǎn)生對象的類型和值會根據(jù)該對象來確定。 對同一屬性引用的多次求值可能產(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. 切片?

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

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)歧義：任何形似表達(dá)式列表的東西同樣也會形似切片列表，因此任何抽取操作也可以被解析為切片。 為了不使句法更加復(fù)雜，于是通過定義將此情況解析為抽取優(yōu)先于解析為切片來消除這種歧義（切片列表未包含正確的切片就屬于此情況）。

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

6.3.4. 調(diào)用?

所謂調(diào)用就是附帶可能為空的一系列 參數(shù) 來執(zhí)行一個可調(diào)用對象 (例如 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

一個可選項(xiàng)為在位置和關(guān)鍵字參數(shù)后加上逗號而不影響語義。

此原型必須求值為一個可調(diào)用對象（用戶定義的函數(shù)，內(nèi)置函數(shù)，內(nèi)置對象的方法，類對象，類實(shí)例的方法以及任何具有 __call__() 方法的對象都是可調(diào)用對象）。 所有參數(shù)表達(dá)式將在嘗試調(diào)用前被求值。 請參閱 函數(shù)定義 一節(jié)了解正式的 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.

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

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

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

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

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

如果函數(shù)調(diào)用中出現(xiàn)了 **expression 句法，expression 必須求值為一個 mapping，其內(nèi)容會被當(dāng)作是額外的關(guān)鍵字參數(shù)。 如果一個關(guān)鍵字已存在（作為顯式關(guān)鍵字參數(shù)，或來自另一個拆包），則將引發(fā) TypeError 異常。

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

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

如果類型為---

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

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

內(nèi)置函數(shù)或方法:

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

類對象:

返回該類的一個新實(shí)例。

類實(shí)例方法:

調(diào)用相應(yīng)的用戶自定義函數(shù)，向其傳入的參數(shù)列表會比調(diào)用的參數(shù)列表多一項(xiàng)：該實(shí)例將成為第一個參數(shù)。

類實(shí)例:

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

6.10.1. 值比較?

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

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

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

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

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

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

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

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

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

• None 和 NotImplemented 都是單例對象。 PEP 8 建議單例對象的比較應(yīng)當(dāng)總是通過 is 或 is not 而不是等于運(yùn)算符來進(jìn)行。

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

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

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

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

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

  內(nèi)置多項(xiàng)集間的字典序比較規(guī)則如下:

  • 兩個多項(xiàng)集若要相等，它們必須為相同類型、相同長度，并且每對相應(yīng)的元素都必須相等（例如，[1,2] == (1,2) 為假值，因?yàn)轭愋筒煌?/p>

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

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

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

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

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

  集合的比較強(qiáng)制規(guī)定其元素的自反射性。

• 大多數(shù)其他內(nèi)置類型沒有實(shí)現(xiàn)比較方法，因此它們會繼承默認(rèn)的比較行為。

在可能的情況下，用戶定義類在定制其比較行為時應(yīng)當(dāng)遵循一些一致性規(guī)則:

• 相等比較應(yīng)該是自反射的。 換句話說，相同的對象比較時應(yīng)該相等:

  x is y 意味著 x == y

• 比較應(yīng)該是對稱的。 換句話說，下列表達(dá)式應(yīng)該有相同的結(jié)果:

  x == y 和 y == x

  x != y 和 y != x

  x < y 和 y > x

  x <= y 和 y >= x

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

  x > y and y > z 意味著 x > z

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

• 反向比較應(yīng)該導(dǎo)致布爾值取反。 換句話說，下列表達(dá)式應(yīng)該有相同的結(jié)果:

  x == y 和 not x != y

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

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

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

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

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

6.10.2. 成員檢測運(yùn)算?

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

對于字符串和字節(jié)串類型來說，當(dāng)且僅當(dāng) x 是 y 的子串時 x in y 為 True。 一個等價的檢測是 y.find(x) != -1。 空字符串總是被視為任何其他字符串的子串，因此 "" in "abc" 將返回 True。

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

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

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

運(yùn)算符 not in 被定義為具有與 in 相反的邏輯值。

6.10.3. 標(biāo)識號比較?

運(yùn)算符 is 和 is not 用于檢測對象的標(biāo)識號：當(dāng)且僅當(dāng) x 和 y 是同一對象時 x is y 為真。 一個對象的標(biāo)識號可使用 id() 函數(shù)來確定。 x is not y 會產(chǎn)生相反的邏輯值。 4