6. 表達(dá)式?

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

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

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

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

6.2.2. 字面值?

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

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

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

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

6.2.3. 帶圓括號(hào)的形式?

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

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

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

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

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

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

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

• 第一種是顯式地列出容器內(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)是一個(gè)單獨(dú)表達(dá)式后面加至少一個(gè) for 子句以及零個(gè)或更多個(gè) for 或 if 子句。 在這種情況下，新容器的元素產(chǎn)生方式是將每個(gè) for 或 if 子句視為一個(gè)代碼塊，按從左至右的順序嵌套，然后每次到達(dá)最內(nèi)層代碼塊時(shí)就對(duì)表達(dá)式進(jìn)行求值以產(chǎn)生一個(gè)元素。

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

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

為了確保推導(dǎo)式得出的結(jié)果總是一個(gè)類型正確的容器，在隱式嵌套作用域內(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. 列表顯示?

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

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

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

6.2.6. 集合顯示?

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

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

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

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

6.2.7. 字典顯示?

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

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è)新的字典對(duì)象。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

下面是對(duì)生成器函數(shù)的描述，異步生成器函數(shù)會(huì)在 異步生成器函數(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 多次，它們具有多個(gè)入口點(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> 時(shí)，所提供的表達(dá)式必須是一個(gè)可迭代對(duì)象。 迭代該可迭代對(duì)象所產(chǎn)生的值會(huì)被直接傳遞給當(dāng)前生成器方法的調(diào)用者。 任何通過 send() 傳入的值以及任何通過 throw() 傳入的異常如果有適當(dāng)?shù)姆椒▌t會(huì)被傳給下層迭代器。 如果不是這種情況，那么 send() 將引發(fā) AttributeError 或 TypeError，而 throw() 將立即引發(fā)所轉(zhuǎn)入的異常。

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

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

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

>>> 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è)名稱的原型:

attributeref ::=  primary "." identifier

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

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

切片就是在序列對(duì)象（字符串、元組或列表）中選擇某個(gè)范圍內(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á)式列表的東西同樣也會(huì)形似切片列表，因此任何抽取操作也可以被解析為切片。 為了不使句法更加復(fù)雜，于是通過定義將此情況解析為抽取優(yōu)先于解析為切片來消除這種歧義（切片列表未包含正確的切片就屬于此情況）。

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

6.3.4. 調(diào)用?

所謂調(diào)用就是附帶可能為空的一系列 參數(shù) 來執(zhí)行一個(gè)可調(diào)用對(duì)象 (例如 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è)可選項(xiàng)為在位置和關(guān)鍵字參數(shù)后加上逗號(hào)而不影響語義。

此原型必須求值為一個(gè)可調(diào)用對(duì)象（用戶定義的函數(shù)，內(nèi)置函數(shù)，內(nèi)置對(duì)象的方法，類對(duì)象，類實(shí)例的方法以及任何具有 __call__() 方法的對(duì)象都是可調(diào)用對(duì)象）。 所有參數(shù)表達(dá)式將在嘗試調(diào)用前被求值。 請(qǐng)參閱 函數(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ù)，將會(huì)引發(fā) TypeError 異常，除非有一個(gè)正式參數(shù)使用了 *identifier 句法；在此情況下，該正式參數(shù)將接受一個(gè)包含了多余位置參數(shù)的元組（如果沒有多余位置參數(shù)則為一個(gè)空元組）。

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

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

這樣做的一個(gè)后果是雖然 *expression 句法可能出現(xiàn)于顯式的關(guān)鍵字參數(shù) 之后，但它會(huì)在關(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 必須求值為一個(gè) mapping，其內(nèi)容會(huì)被當(dāng)作是額外的關(guān)鍵字參數(shù)。 如果一個(gè)關(guān)鍵字已存在（作為顯式關(guān)鍵字參數(shù)，或來自另一個(gè)拆包），則將引發(fā) TypeError 異常。

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

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

如果類型為---

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

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

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

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

類對(duì)象:

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

類實(shí)例方法:

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

類實(shí)例:

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

6.10.1. 值比較?

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

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

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

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

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

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

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

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

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

• None 和 NotImplemented 都是單例對(duì)象。 PEP 8 建議單例對(duì)象的比較應(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 還有一個(gè)限制是不支持次序比較。 以上對(duì)象的跨類型一致性比較結(jié)果將是不相等，跨類型次序比較將引發(fā) TypeError。

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

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

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

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

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

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

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

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

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

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

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

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

  x is y 意味著 x == y

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

  x == y 和 y == x

  x != y 和 y != x

  x < y 和 y > x

  x <= y 和 y >= x

• 比較應(yīng)該是可傳遞的。 下列（簡(jiǎn)要的）例子顯示了這一點(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 (對(duì)于完全排序)

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

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

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

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

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

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

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

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

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

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

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

6.10.3. 標(biāo)識(shí)號(hào)比較?

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