掃二維碼與項(xiàng)目經(jīng)理溝通
我們在微信上24小時期待你的聲音
解答本文疑問/技術(shù)咨詢/運(yùn)營咨詢/技術(shù)建議/互聯(lián)網(wǎng)交流
本章將解釋 python 中組成表達(dá)式的各種元素的的含義。
邵東網(wǎng)站制作公司哪家好，找創(chuàng)新互聯(lián)建站！從網(wǎng)頁設(shè)計(jì)、網(wǎng)站建設(shè)、微信開發(fā)、APP開發(fā)、響應(yīng)式網(wǎng)站開發(fā)等網(wǎng)站項(xiàng)目制作，到程序開發(fā)，運(yùn)營維護(hù)。創(chuàng)新互聯(lián)建站自2013年創(chuàng)立以來到現(xiàn)在10年的時間，我們擁有了豐富的建站經(jīng)驗(yàn)和運(yùn)維經(jīng)驗(yàn)，來保證我們的工作的順利進(jìn)行。專注于網(wǎng)站建設(shè)就選創(chuàng)新互聯(lián)建站。
語法注釋: 在本章和后續(xù)章節(jié)中，會使用擴(kuò)展 BNF 標(biāo)注來描述語法而不是詞法分析。 當(dāng)（某種替代的）語法規(guī)則具有如下形式
- name ::=
othername
并且沒有給出語義，則這種形式的 name 在語法上與 othername 相同。
當(dāng)對下述某個算術(shù)運(yùn)算符的描述中使用了“數(shù)值參數(shù)被轉(zhuǎn)換為普通類型”這樣的說法，這意味著內(nèi)置類型的運(yùn)算符實(shí)現(xiàn)采用了如下運(yùn)作方式:
如果任一參數(shù)為復(fù)數(shù)，另一參數(shù)會被轉(zhuǎn)換為復(fù)數(shù)；
否則，如果任一參數(shù)為浮點(diǎn)數(shù)，另一參數(shù)會被轉(zhuǎn)換為浮點(diǎn)數(shù)；
否則，兩者應(yīng)該都為整數(shù)，不需要進(jìn)行轉(zhuǎn)換。
某些附加規(guī)則會作用于特定運(yùn)算符（例如，字符串作為 ‘%’ 運(yùn)算符的左運(yùn)算參數(shù)）。 擴(kuò)展必須定義它們自己的轉(zhuǎn)換行為。
“原子”指表達(dá)式的最基本構(gòu)成元素。 最簡單的原子是標(biāo)識符和字面值。 以圓括號、方括號或花括號包括的形式在語法上也被歸類為原子。 原子的句法為:
- atom ::= identifier | literal | enclosure
- enclosure ::= parenth_form | list_display | dict_display | set_display
- | generator_expression | yield_atom
作為原子出現(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)定義的截?cái)唷?如果類名僅由下劃線組成，則不會進(jìn)行轉(zhuǎn)換。
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ā)生在程序文本的相同位置還是不同位置）可能得到相同對象或是具有相同值的不同對象。
帶圓括號的形式是包含在圓括號中的可選表達(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)生的對象可能相同也可能不同）。
Note that tuples are not formed by the parentheses, but rather by use of the comma. The exception is the empty tuple, for which parentheses are required —- allowing unparenthesized “nothing” in expressions would cause ambiguities and allow common typos to pass uncaught.
為了構(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.
3.6 新版功能: 引入了異步推導(dǎo)式。
在 3.8 版更改: yield 和 yield from 在隱式嵌套的作用域中已被禁用。
在 3.11 版更改: Asynchronous comprehensions are now allowed inside comprehensions in asynchronous functions. Outer comprehensions implicitly become asynchronous.
列表顯示是一個用方括號括起來的可能為空的表達(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)建。
集合顯示是用花括號標(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)建的是一個空字典。
字典顯示是一個用花括號括起來的可能為空的鍵/數(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è)置的值。
3.5 新版功能: 拆包到字典顯示，最初由 PEP 448 提出。
字典推導(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ù)。
在 3.8 版更改: 在 Python 3.8 之前的字典推導(dǎo)式中，并沒有定義好鍵和值的求值順序。 在 CPython 中，值會先于鍵被求值。 根據(jù) PEP 572 的提議，從 3.8 開始，鍵會先于值被求值。
生成器表達(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á)式會返回一個新的異步生成器對象，此對象屬于異步迭代器 (參見 異步迭代器)。
3.6 新版功能: 引入了異步生成器表達(dá)式。
在 3.7 版更改: 在 Python 3.7 之前，異步生成器表達(dá)式只能在 async def 協(xié)和中出現(xiàn)。 從 3.7 開始，任何函數(shù)都可以使用異步生成器表達(dá)式。
在 3.8 版更改: yield 和 yield from 在隱式嵌套的作用域中已被禁用。
- yield_atom ::= "(" yield_expression ")"
- yield_expression ::= "yield" [expression_list | "from" expression]
yield 表達(dá)式在定義 generator 函數(shù)或 asynchronous generator 函數(shù)時才會用到因此只能在函數(shù)定義的內(nèi)部使用。 在一個函數(shù)體內(nèi)使用 yield 表達(dá)式會使這個函數(shù)變成一個生成器函數(shù)，而在一個 async def 函數(shù)的內(nèi)部使用它則會讓這個協(xié)程函數(shù)變成一個異步生成器函數(shù)。 例如:
def gen(): # defines a generator functionyield 123async def agen(): # defines an asynchronous generator functionyield 123
由于它們會對外層作用域造成附帶影響，yield 表達(dá)式不被允許作為用于實(shí)現(xiàn)推導(dǎo)式和生成器表達(dá)式的隱式定義作用域的一部分。
在 3.8 版更改: 禁止在實(shí)現(xiàn)推導(dǎo)式和生成器表達(dá)式的隱式嵌套作用域中使用 yield 表達(dá)式。
下面是對生成器函數(shù)的描述，異步生成器函數(shù)會在 異步生成器函數(shù) 一節(jié)中單獨(dú)介紹。
當(dāng)一個生成器函數(shù)被調(diào)用時，它返回一個名為生成器的迭代器。 然后這個生成器將控制生成器函數(shù)的執(zhí)行。 執(zhí)行過程會在這個生成器的某個方法被調(diào)用時開始。 這時，函數(shù)會執(zhí)行到第一個 yield 表達(dá)式，在這里它將再次被掛起，向生成器的調(diào)用方返回 expression_list 的值。 我們所謂的掛起，就是說所有局部狀態(tài)都會被保留下來，包括局部變量的當(dāng)前綁定、指令指針、內(nèi)部求值棧和任何異常處理等等。 當(dāng)通過調(diào)用生成器的某個方法恢復(fù)執(zhí)行時，這個函數(shù)的運(yùn)行就與 yield 表達(dá)式只是一個外部調(diào)用的情況完全一樣。 恢復(fù)之后 yield 表達(dá)式的值取決于恢復(fù)執(zhí)行所調(diào)用的方法。 如果是用 __next__() (通常是通過 for 或 next() 內(nèi)置函數(shù)) 則結(jié)果為 None。 否則，如果是用 send()，則結(jié)果將為傳給該方法的值。
所有這些使生成器函數(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 時，所提供的表達(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以委托控制流給一個子迭代器。
當(dāng)yield表達(dá)式是賦值語句右側(cè)的唯一表達(dá)式時，括號可以省略。
參見
PEP 255 - 簡單生成器
在 Python 中加入生成器和 yield 語句的提議。
PEP 342 - 通過增強(qiáng)型生成器實(shí)現(xiàn)協(xié)程
增強(qiáng)生成器 API 和語法的提議，使其可以被用作簡單的協(xié)程。
PEP 380 - 委托給子生成器的語法
引入 yield_from 語法的提議，以方便地委托給子生成器。
PEP 525 - 異步生成器
通過給協(xié)程函數(shù)加入生成器功能對 PEP 492 進(jìn)行擴(kuò)展的提議。
這個子小節(jié)描述了生成器迭代器的方法。 它們可被用于控制生成器函數(shù)的執(zhí)行。
請注意在生成器已經(jīng)在執(zhí)行時調(diào)用以下任何方法都會引發(fā) ValueError 異常。
generator.__next__()
開始一個生成器函數(shù)的執(zhí)行或是從上次執(zhí)行 yield 表達(dá)式的位置恢復(fù)執(zhí)行。 當(dāng)一個生成器函數(shù)通過 __next__() 方法恢復(fù)執(zhí)行時，當(dāng)前的 yield 表達(dá)式總是取值為 None。 隨后會繼續(xù)執(zhí)行到下一個 yield 表達(dá)式，這時生成器將再次掛起，而 expression_list 的值會被返回給 __next__() 的調(diào)用方。 如果生成器沒有產(chǎn)生下一個值就退出，則將引發(fā) StopIteration 異常。
此方法通常是隱式地調(diào)用，例如通過 for 循環(huán)或是內(nèi)置的 next() 函數(shù)。
generator.send(value)
恢復(fù)執(zhí)行并向生成器函數(shù)“發(fā)送”一個值。 value 參數(shù)將成為當(dāng)前 yield 表達(dá)式的結(jié)果。 send() 方法會返回生成器所產(chǎn)生的下一個值，或者如果生成器沒有產(chǎn)生下一個值就退出則會引發(fā) StopIteration。 當(dāng)調(diào)用 send() 來啟動生成器時，它必須以 None 作為調(diào)用參數(shù)，因?yàn)檫@時沒有可以接收值的 yield 表達(dá)式。
generator.throw(value)
generator.throw(type[, value[, traceback]])
在生成器暫停的位置引發(fā)一個異常，并返回該生成器函數(shù)所產(chǎn)生的下一個值。 如果生成器沒有產(chǎn)生下一個值就退出，則將引發(fā) StopIteration 異常。 如果生成器函數(shù)沒有捕獲傳入的異常，或是引發(fā)了另一個異常，則該異常會被傳播給調(diào)用方。
在典型的使用場景下，其調(diào)用將附帶單個異常實(shí)例，類似于使用 raise 關(guān)鍵字的方式。
For backwards compatibility, however, the second signature is supported, following a convention from older versions of Python. The type argument should be an exception class, and value should be an exception instance. If the value is not provided, the type constructor is called to get an instance. If traceback is provided, it is set on the exception, otherwise any existing __traceback__ attribute stored in value may be cleared.
generator.close()
在生成器函數(shù)暫停的位置引發(fā) GeneratorExit。 如果之后生成器函數(shù)正常退出、關(guān)閉或引發(fā) GeneratorExit (由于未捕獲該異常) 則關(guān)閉并返回其調(diào)用者。 如果生成器產(chǎn)生了一個值，關(guān)閉會引發(fā) RuntimeError。 如果生成器引發(fā)任何其他異常，它會被傳播給調(diào)用者。 如果生成器已經(jīng)由于異?；蛘Ｍ顺鰟t close() 不會做任何事。
這里是一個簡單的例子，演示了生成器和生成器函數(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.
對于 yield from 的例子, 參見“Python 有什么新變化”中的 PEP 380: 委托給子生成器的語法。
在一個使用 async def 定義的函數(shù)或方法中出現(xiàn)的 yield 表達(dá)式會進(jìn)一步將該函數(shù)定義為一個 asynchronous generator 函數(shù)。
當(dāng)一個異步生成器函數(shù)被調(diào)用時，它會返回一個名為異步生成器對象的異步迭代器。 此對象將在之后控制該生成器函數(shù)的執(zhí)行。 異步生成器對象通常被用在協(xié)程函數(shù)的 async for 語句中，類似于在 for 語句中使用生成器對象。
調(diào)用某個異步生成器的方法將返回 awaitable 對象，執(zhí)行會在此對象被等待時啟動。 到那時，執(zhí)行過程將前往第一個 yield 表達(dá)式，在那里它會再次掛起，將 expression_list 的值返回給等待中的協(xié)程。 與生成器一樣，掛起意味著所有局部狀態(tài)會被保留，包括局部變量的當(dāng)前綁定、指令指針、內(nèi)部求值棧以及任何異常處理的狀態(tài)。 當(dāng)執(zhí)行在等待異步生成器的方法返回下一個對象后恢復(fù)時，該函數(shù)可以從原狀態(tài)繼續(xù)執(zhí)行，就仿佛 yield 表達(dá)式只是另一個外部調(diào)用。 恢復(fù)執(zhí)行之后 yield 表達(dá)式的值取決于恢復(fù)執(zhí)行所用的方法。 如果使用 __anext__() 則結(jié)果為 None。 否則的話，如果使用 asend()，則結(jié)果將是傳遞給該方法的值。
如果一個異步生成器恰好因 break、調(diào)用方任務(wù)被取消，或是其他異常而提前退出，生成器的異步清理代碼將會運(yùn)行并可能引發(fā)異常或訪問意外上下文中的上下文變量 — 也許是在它所依賴的任務(wù)的生命周期之后，或是在異步生成器垃圾回收鉤子被調(diào)用時的事件循環(huán)關(guān)閉期間。 為了防止這種情況，調(diào)用方必須通過調(diào)用 aclose() 方法來顯式地關(guān)閉異步生成器以終結(jié)生成器并最終從事件循環(huán)中將其分離。
在異步生成器函數(shù)中，yield 表達(dá)式允許出現(xiàn)在 try 結(jié)構(gòu)的任何位置。 但是，如果一個異步生成器在其被終結(jié)（由于引用計(jì)數(shù)達(dá)到零或被作為垃圾回收）之前未被恢復(fù)，則then a yield expression within a try 結(jié)構(gòu)中的 yield 表達(dá)式可能導(dǎo)致掛起的 finally 子句執(zhí)行失敗。 在此情況下，應(yīng)由運(yùn)行該異步生成器的事件循環(huán)或任務(wù)調(diào)度器來負(fù)責(zé)調(diào)用異步生成器-迭代器的 aclose() 方法并運(yùn)行所返回的協(xié)程對象，從而允許任何掛起的 finally 子句得以執(zhí)行。
為了能在事件循環(huán)終結(jié)時執(zhí)行最終化處理，事件循環(huán)應(yīng)當(dāng)定義一個 終結(jié)器 函數(shù)，它接受一個異步生成器迭代器并將調(diào)用 aclose() 且執(zhí)行該協(xié)程。 這個 終結(jié)器 可以通過調(diào)用 sys.set_asyncgen_hooks() 來注冊。 當(dāng)首次迭代時，異步生成器迭代器將保存已注冊的 終結(jié)器 以便在最終化時調(diào)用。 有關(guān) 終結(jié)器 方法的參考示例請查看在 Lib/asyncio/base_events.py 的中的 asyncio.Loop.shutdown_asyncgens 實(shí)現(xiàn)。
yield from 表達(dá)式如果在異步生成器函數(shù)中使用會引發(fā)語法錯誤。
這個子小節(jié)描述了異步生成器迭代器的方法，它們可被用于控制生成器函數(shù)的執(zhí)行。
coroutine agen.__anext__()
返回一個可等待對象，它在運(yùn)行時會開始執(zhí)行該異步生成器或是從上次執(zhí)行的 yield 表達(dá)式位置恢復(fù)執(zhí)行。 當(dāng)一個異步生成器函數(shù)通過 __anext__() 方法恢復(fù)執(zhí)行時，當(dāng)前的 yield 表達(dá)式所返回的可等待對象總是取值為 None，它在運(yùn)行時將繼續(xù)執(zhí)行到下一個 yield 表達(dá)式。 該 yield 表達(dá)式的 expression_list 的值會是完成的協(xié)程所引發(fā)的 StopIteration 異常的值。 如果異步生成器沒有產(chǎn)生下一個值就退出，則該可等待對象將引發(fā) StopAsyncIteration 異常，提示該異步迭代操作已完成。
此方法通常是通過 async for 循環(huán)隱式地調(diào)用。
coroutine agen.asend(value)
返回一個可等待對象，它在運(yùn)行時會恢復(fù)該異步生成器的執(zhí)行。 與生成器的 send() 方法一樣，此方法會“發(fā)送”一個值給異步生成器函數(shù)，其 value 參數(shù)會成為當(dāng)前 yield 表達(dá)式的結(jié)果值。 asend() 方法所返回的可等待對象將返回生成器產(chǎn)生的下一個值，其值為所引發(fā)的 StopIteration，或者如果異步生成器沒有產(chǎn)生下一個值就退出則引發(fā) StopAsyncIteration。 當(dāng)調(diào)用 asend() 來啟動異步生成器時，它必須以 None 作為調(diào)用參數(shù)，因?yàn)檫@時沒有可以接收值的 yield 表達(dá)式。
coroutine agen.athrow(type[, value[, traceback]])
返回一個可等待對象，它會在異步生成器暫停的位置引發(fā) type 類型的異常，并返回該生成器函數(shù)所產(chǎn)生的下一個值，其值為所引發(fā)的 StopIteration 異常。 如果異步生成器沒有產(chǎn)生下一個值就退出，則將由該可等待對象引發(fā) StopAsyncIteration 異步。 如果生成器函數(shù)沒有捕獲傳入的異常，或引發(fā)了另一個異常，則當(dāng)可等待對象運(yùn)行時該異常會被傳播給可等待對象的調(diào)用者。
coroutine agen.aclose()
返回一個可等待對象，它會在運(yùn)行時向異步生成器函數(shù)暫停的位置拋入一個 GeneratorExit。 如果該異步生成器函數(shù)正常退出、關(guān)閉或引發(fā) GeneratorExit (由于未捕獲該異常) 則返回的可等待對象將引發(fā) StopIteration 異常。 后續(xù)調(diào)用異步生成器所返回的任何其他可等待對象將引發(fā) StopAsyncIteration 異常。 如果異步生成器產(chǎn)生了一個值，該可等待對象會引發(fā) RuntimeError。 如果異步生成器引發(fā)任何其他異常，它會被傳播給可等待對象的調(diào)用者。 如果異步生成器已經(jīng)由于異常或正常退出則后續(xù)調(diào)用 aclose() 將返回一個不會做任何事的可等待對象。
原型代表編程語言中最緊密綁定的操作。 它們的句法如下:
- primary ::= atom | attributeref | subscription | slicing | call
屬性引用是后面帶有一個句點(diǎn)加一個名稱的原型:
- attributeref ::= primary "." identifier
此原型必須求值為一個支持屬性引用的類型的對象，多數(shù)對象都支持屬性引用。 隨后該對象會被要求產(chǎn)生以指定標(biāo)識符為名稱的屬性。 這個產(chǎn)生過程可通過重載 __getattr__() 方法來自定義。 如果這個屬性不可用，則將引發(fā) AttributeError 異常。 否則的話，所產(chǎn)生對象的類型和值會根據(jù)該對象來確定。 對同一屬性引用的多次求值可能產(chǎn)生不同的對象。
對一個 容器類 的實(shí)例執(zhí)行抽取操作通常將會從該容器中選取一個元素。 而對一個 泛型類 執(zhí)行抽取操作通常將會返回一個 GenericAlias 對象。
- subscription ::= primary "[" expression_list "]"
當(dāng)一個對象被抽取時，解釋器將對原型和表達(dá)式列表進(jìn)行求值。
原型必須可被求值為一個支持抽取操作的對象。 一個對象可通過同時定義 __getitem__() 和 __class_getitem__() 或其中之一來支持抽取操作。 當(dāng)原型被抽取時，表達(dá)式列表的求值結(jié)果將被傳給以上方法中的一個。 對于在何時會調(diào)用 __class_getitem__ 而不是 __getitem__ 的更多細(xì)節(jié)，請參閱 __class_getitem__ 與 __getitem__。
如果表達(dá)式列表包含至少一個逗號，它將被求值為包含該表達(dá)式列表中所有條目的 tuple。 在其他情況下，表達(dá)式列表將被求值為列表中唯一成員的值。
對于內(nèi)置對象，有兩種類型的對象支持通過 __getitem__() 執(zhí)行抽取操作:
映射。 如果原型是一個 mapping，則表達(dá)式列表必須求值為一個以該映射的某個鍵為值的對象，而抽取操作會在映射中選取該鍵所對應(yīng)的值。 內(nèi)置映射類的一個例子是 dict 類。
序列。 如果原型是一個 sequence，則表達(dá)式列表必須求值為一個 int 或一個 slice (如下面的小節(jié)所討論的)。 內(nèi)置序列類的例子包括 str, list 和 tuple 等類。
正式語法規(guī)則并未在 序列 中設(shè)置負(fù)索引號的特殊保留條款。 不過，內(nèi)置序列都提供了通過給索引號加上序列長度來解讀負(fù)索引號的 __getitem__() 方法，因此舉例來說，x[-1] 將選取 x 的最后一項(xiàng)。 結(jié)果值必須為一個小于序列中條目數(shù)的非負(fù)整數(shù)，抽取操作會選取索引號為該值的條目（從零開始計(jì)數(shù)）。 由于對負(fù)索引號和切片的支持位于對象的 __getitem__() 方法中，因而重載此方法的子類將需要顯式地添加這種支持。
字符串 是一種特殊的序列，其中的項(xiàng)是 字符。 字符并不是一種單獨(dú)的數(shù)據(jù)類型而是長度恰好為一個字符的字符串。
切片就是在序列對象（字符串、元組或列表）中選擇某個范圍內(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 來替換。
所謂調(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.
CPython 實(shí)現(xiàn)細(xì)節(jié)： 某些實(shí)現(xiàn)可能提供位置參數(shù)沒有名稱的內(nèi)置函數(shù)，即使它們在文檔說明的場合下有“命名”，因此不能以關(guān)鍵字形式提供參數(shù)。 在 CPython 中，以 C 編寫并使用 PyArg_ParseTuple() 來解析其參數(shù)的函數(shù)實(shí)現(xiàn)就屬于這種情況。
如果存在比正式參數(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，則它就等價(jià)于一個帶有 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 "", line 1, in 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.
If the syntax **expression appears in the function call, expression must evaluate to a mapping, the contents of which are treated as additional keyword arguments. If a parameter matching a key has already been given a value (by an explicit keyword argument, or from another unpacking), a TypeError exception is raised.
When **expression is used, each key in this mapping must be a string. Each value from the mapping is assigned to the first formal parameter eligible for keyword assignment whose name is equal to the key. A key need not be a Python identifier (e.g. "max-temp °F" is acceptable, although it will not match any formal parameter that could be declared). If there is no match to a formal parameter the key-value pair is collected by the ** parameter, if there is one, or if there is not, a TypeError exception is raised.
使用 *identifier 或 **identifier 句法的正式參數(shù)不能被用作位置參數(shù)空位或關(guān)鍵字參數(shù)名稱。
在 3.5 版更改: 函數(shù)調(diào)用接受任意數(shù)量的 * 和 ** 拆包，位置參數(shù)可能跟在可迭代對象拆包 (*) 之后，而關(guān)鍵字參數(shù)可能跟在字典拆包 (**) 之后。 由 PEP 448 發(fā)起最初提議。
除非引發(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__() 方法；作用效果將等價(jià)于調(diào)用該方法。
掛起 coroutine 的執(zhí)行以等待一個 awaitable 對象。 只能在 coroutine function 內(nèi)部使用。
- await_expr ::= "await" primary
3.5 新版功能.
冪運(yùn)算符的綁定比在其左側(cè)的一元運(yùn)算符更緊密；但綁定緊密程度不及在其右側(cè)的一元運(yùn)算符。 句法如下:
- power ::= (await_expr | primary) ["**" u_expr]
因此，在一個未加圓括號的冪運(yùn)算符和單目運(yùn)算符序列中，運(yùn)算符將從右向左求值（這不會限制操作數(shù)的求值順序）: -1**2 結(jié)果將為 -1。
冪運(yùn)算符與附帶兩個參數(shù)調(diào)用內(nèi)置 pow() 函數(shù)具有相同的語義：結(jié)果為對其左參數(shù)進(jìn)行其右參數(shù)所指定冪次的乘方運(yùn)算。 數(shù)值參數(shù)會先轉(zhuǎn)換為相同類型，結(jié)果也為轉(zhuǎn)換后的類型。
對于 int 類型的操作數(shù)，結(jié)果將具有與操作數(shù)相同的類型，除非第二個參數(shù)為負(fù)數(shù)；在那種情況下，所有參數(shù)會被轉(zhuǎn)換為 float 類型并輸出 float 類型的結(jié)果。 例如，10**2 返回 100，而 10**-2 返回 0.01。
對 0.0 進(jìn)行負(fù)數(shù)冪次運(yùn)算將導(dǎo)致 ZeroDivisionError。 對負(fù)數(shù)進(jìn)行分?jǐn)?shù)冪次運(yùn)算將返回 complex 數(shù)值。 （在早期版本中這將引發(fā) ValueError。）
此運(yùn)算符可使用特殊的 __pow__() 方法來自定義。
所有算術(shù)和位運(yùn)算具有相同的優(yōu)先級:
- u_expr ::= power | "-" u_expr | "+" u_expr | "~" u_expr
一元的 - (負(fù)值) 運(yùn)算符會產(chǎn)生其數(shù)字參數(shù)的負(fù)值；該運(yùn)算可通過 __neg__() 特殊方法來重載。
一元的 + (正值) 運(yùn)算符會原樣輸出其數(shù)字參數(shù)；該運(yùn)算可通過 __pos__() 特殊方法來重載。
一元的 ~ (取反) 運(yùn)算符會對其整數(shù)參數(shù)按位取反。 x 的按位取反被定義為 -(x+1)。 它只作用于整數(shù)或是重載了 __invert__() 特殊方法的自定義對象。
在所有三種情況下，如果參數(shù)的類型不正確，將引發(fā) TypeError 異常。
二元算術(shù)運(yùn)算符遵循傳統(tǒng)的優(yōu)先級。 請注意某些此類運(yùn)算符也作用于特定的非數(shù)字類型。 除冪運(yùn)算符以外只有兩個優(yōu)先級別，一個作用于乘法型運(yùn)算符，另一個作用于加法型運(yùn)算符:
- m_expr ::= u_expr | m_expr "*" u_expr | m_expr "@" m_expr |
- m_expr "http://" u_expr | m_expr "/" u_expr |
- m_expr "%" u_expr
- a_expr ::= m_expr | a_expr "+" m_expr | a_expr "-" m_expr
運(yùn)算符 * (乘) 將輸出其參數(shù)的乘積。 兩個參數(shù)或者必須都為數(shù)字，或者一個參數(shù)必須為整數(shù)而另一個參數(shù)必須為序列。 在前一種情況下，兩個數(shù)字將被轉(zhuǎn)換為相同類型然后相乘。 在后一種情況下，將執(zhí)行序列的重復(fù)；重復(fù)因子為負(fù)數(shù)將輸出空序列。
此運(yùn)算可使用特殊的 __mul__() 和 __rmul__() 方法來自定義。
運(yùn)算符 @ (at) 的目標(biāo)是用于矩陣乘法。 沒有內(nèi)置 Python 類型實(shí)現(xiàn)此運(yùn)算符。
3.5 新版功能.
運(yùn)算符 / (除) 和 // (整除) 將輸出其參數(shù)的商。 兩個數(shù)字參數(shù)將先被轉(zhuǎn)換為相同類型。 整數(shù)相除會輸出一個 float 值，整數(shù)相整除的結(jié)果仍是整數(shù)；整除的結(jié)果就是使用 ‘floor’ 函數(shù)進(jìn)行算術(shù)除法的結(jié)果。 除以零的運(yùn)算將引發(fā) ZeroDivisionError 異常。
此運(yùn)行可使用特殊的 __truediv__() 和 __floordiv__() 方法來自定義。
運(yùn)算符 % (模) 將輸出第一個參數(shù)除以第二個參數(shù)的余數(shù)。 兩個數(shù)字參數(shù)將先被轉(zhuǎn)換為相同類型。 右參數(shù)為零將引發(fā) ZeroDivisionError 異常。 參數(shù)可以為浮點(diǎn)數(shù)，例如 3.14%0.7 等于 0.34 (因?yàn)?3.14 等于 4*0.7 + 0.34)。 模運(yùn)算符的結(jié)果的正負(fù)總是與第二個操作數(shù)一致（或是為零）；結(jié)果的絕對值一定小于第二個操作數(shù)的絕對值 1。
整除與模運(yùn)算符的聯(lián)系可通過以下等式說明: x == (x//y)*y + (x%y)。 此外整除與模也可通過內(nèi)置函數(shù) divmod() 來同時進(jìn)行: divmod(x, y) == (x//y, x%y)。 2。
除了對數(shù)字執(zhí)行模運(yùn)算，運(yùn)算符 % 還被字符串對象重載用于執(zhí)行舊式的字符串格式化（又稱插值）。 字符串格式化句法的描述參見 Python 庫參考的 printf 風(fēng)格的字符串格式化 一節(jié)。
取余 運(yùn)算可使用特殊的 __mod__() 方法來自定義。
整除運(yùn)算符，模運(yùn)算符和 divmod() 函數(shù)未被定義用于復(fù)數(shù)。 如果有必要可以使用 abs() 函數(shù)將其轉(zhuǎn)換為浮點(diǎn)數(shù)。
運(yùn)算符 + (addition) 將輸出其參數(shù)的和。 兩個參數(shù)或者必須都為數(shù)字，或者都為相同類型的序列。 在前一種情況下，兩個數(shù)字將被轉(zhuǎn)換為相同類型然后相加。 在后一種情況下，將執(zhí)行序列拼接操作。
此運(yùn)算可使用特殊的 __add__() 和 __radd__() 方法來自定義。
運(yùn)算符 - (減) 將輸出其參數(shù)的差。 兩個數(shù)字參數(shù)將先被轉(zhuǎn)換為相同類型。
此運(yùn)算可使用特殊的 __sub__() 方法來自定義。
移位運(yùn)算的優(yōu)先級低于算術(shù)運(yùn)算:
- shift_expr ::= a_expr | shift_expr ("<<" | ">>") a_expr
這些運(yùn)算符接受整數(shù)參數(shù)。 它們會將第一個參數(shù)左移或右移第二個參數(shù)所指定的比特位數(shù)。
此運(yùn)算可使用特殊的 __lshift__() 和 __rshift__() 方法來自定義。
右移 n 位被定義為被 pow(2,n) 整除。 左移 n 位被定義為乘以 pow(2,n)。
三種位運(yùn)算具有各不相同的優(yōu)先級:
- and_expr ::= shift_expr | and_expr "&" shift_expr
- xor_expr ::= and_expr | xor_expr "^" and_expr
- or_expr ::= xor_expr | or_expr "|" xor_expr
& 運(yùn)算符會對其參數(shù)執(zhí)行按位 AND，參數(shù)必須都為整數(shù)或者其中之一必須為重載了 __and__() 或 __rand__() 特殊方法的自定義對象。
^ 運(yùn)算符會對其參數(shù)執(zhí)行按位 XOR (異 OR)，參數(shù)必須都為整數(shù)或者其中之一必須為重載了 __xor__() 或 __rxor__() 特殊方法的自定義對象。
| 運(yùn)算符會對其參數(shù)執(zhí)行按位 (合并) OR，參數(shù)必須都為整數(shù)或者其中之一必須為重載了 __or__() 或 __ror__() 特殊方法的自定義對象。
與 C 不同，Python 中所有比較運(yùn)算的優(yōu)先級相同，低于任何算術(shù)、移位或位運(yùn)算。 另一個與 C 不同之處在于 a < b < c 這樣的表達(dá)式會按傳統(tǒng)算術(shù)法則來解讀:
- comparison ::= or_expr (comp_operator or_expr)*
- comp_operator ::= "<" | ">" | "==" | ">=" | "<=" | "!="
- | "is" ["not"] | ["not"] "in"
比較運(yùn)算會產(chǎn)生布爾值: True 或 False。 自定義的 富比較方法 可能返回非布爾值。 在此情況下 Python 將在布爾運(yùn)算上下文中對該值調(diào)用 bool()。
比較運(yùn)算可以任意串連，例如 x < y <= z 等價(jià)于 x < y and y <= z，除了 y 只被求值一次（但在兩種寫法下當(dāng) x < y 值為假時 z 都不會被求值）。
正式的說法是這樣：如果 a, b, c, …, y, z 為表達(dá)式而 op1, op2, …, opN 為比較運(yùn)算符，則 a op1 b op2 c ... y opN z 就等價(jià)于 a op1 b and b op2 c and ... y opN z，不同點(diǎn)在于每個表達(dá)式最多只被求值一次。
請注意 a op1 b op2 c 不意味著在 a 和 c 之間進(jìn)行任何比較，因此，如 x < y > z 這樣的寫法是完全合法的（雖然也許不太好看）。
運(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 或 byte
分享標(biāo)題：創(chuàng)新互聯(lián)Python教程：6. 表達(dá)式
分享網(wǎng)址：http://uogjgqi.cn/article/djdocoi.html
我們在微信上24小時期待你的聲音
解答本文疑問/技術(shù)咨詢/運(yùn)營咨詢/技術(shù)建議/互聯(lián)網(wǎng)交流
微信二維碼
微信二維碼
移動版官網(wǎng)