7.1. 表達式語(yǔ)句?

表達式語(yǔ)句用于計算和寫(xiě)入值（大多是在交互模式下），或者（通常情況）調用一個(gè)過(guò)程 (過(guò)程就是不返回有意義結果的函數；在 Python 中，過(guò)程的返回值為 None)。 表達式語(yǔ)句的其他使用方式也是允許且有特定用處的。 表達式語(yǔ)句的句法為:

expression_stmt ::=  starred_expression

表達式語(yǔ)句會(huì )對指定的表達式列表（也可能為單一表達式）進(jìn)行求值。

在交互模式下，如果結果值不為 None，它會(huì )通過(guò)內置的 repr() 函數轉換為一個(gè)字符串，該結果字符串將以單獨一行的形式寫(xiě)入標準輸出（例外情況是如果結果為 None，則該過(guò)程調用不產(chǎn)生任何輸出。）

7.2. 賦值語(yǔ)句?

賦值語(yǔ)句用于將名稱(chēng)（重）綁定到特定值，以及修改屬性或可變對象的成員項:

assignment_stmt ::=  (target_list "=")+ (starred_expression | yield_expression)
target_list     ::=  target ("," target)* [","]
target          ::=  identifier
                     | "(" [target_list] ")"
                     | "[" [target_list] "]"
                     | attributeref
                     | subscription
                     | slicing
                     | "*" target

(請參閱 原型 一節了解 屬性引用, 抽取 和 切片 的句法定義。)

賦值語(yǔ)句會(huì )對指定的表達式列表進(jìn)行求值（注意這可能為單一表達式或是由逗號分隔的列表，后者將產(chǎn)生一個(gè)元組）并將單一結果對象從左至右逐個(gè)賦值給目標列表。

賦值是根據目標（列表）的格式遞歸地定義的。 當目標為一個(gè)可變對象（屬性引用、抽取或切片）的組成部分時(shí)，該可變對象必須最終執行賦值并決定其有效性，如果賦值操作不可接受也可能引發(fā)異常。 各種類(lèi)型可用的規則和引發(fā)的異常通過(guò)對象類(lèi)型的定義給出（參見(jiàn) 標準類(lèi)型層級結構 一節）。

對象賦值的目標對象可以包含于圓括號或方括號內，具體操作按以下方式遞歸地定義。

• 如果目標列表為后面不帶逗號、可以包含于圓括號內的單一目標，則將對象賦值給該目標。

• Else:

  • 如果目標列表包含一個(gè)帶有星號前綴的目標，這稱(chēng)為“加星”目標：則該對象至少必須為與目標列表項數減一相同項數的可迭代對象。 該可迭代對象前面的項將按從左至右的順序被賦值給加星目標之前的目標。 該可迭代對象末尾的項將被賦值給加星目標之后的目標。 然后該可迭代對象中剩余項的列表將被賦值給加星目標（該列表可以為空）。

  • 否則：該對象必須為具有與目標列表相同項數的可迭代對象，這些項將按從左至右的順序被賦值給對應的目標。

對象賦值給單個(gè)目標的操作按以下方式遞歸地定義。

• 如果目標為標識符（名稱(chēng)）:

  • 如果該名稱(chēng)未出現于當前代碼塊的 global 或 nonlocal 語(yǔ)句中：該名稱(chēng)將被綁定到當前局部命名空間的對象。

  • 否則：該名稱(chēng)將被分別綁定到全局命名空間或由 nonlocal 所確定的外層命名空間的對象。

  如果該名稱(chēng)已經(jīng)被綁定則將被重新綁定。 這可能導致之前被綁定到該名稱(chēng)的對象的引用計數變?yōu)榱?，造成該對象進(jìn)入釋放過(guò)程并調用其析構器（如果存在）。

• 如果該對象為屬性引用：引用中的原型表達式會(huì )被求值。 它應該產(chǎn)生一個(gè)具有可賦值屬性的對象；否則將引發(fā) TypeError。 該對象會(huì )被要求將可賦值對象賦值給指定的屬性；如果它無(wú)法執行賦值，則會(huì )引發(fā)異常 (通常應為 AttributeError 但并不強制要求)。

  注意：如果該對象為類(lèi)實(shí)例并且屬性引用在賦值運算符的兩側都出現，則右側表達式 a.x 可以訪(fǎng)問(wèn)實(shí)例屬性或（如果實(shí)例屬性不存在）類(lèi)屬性。 左側目標 a.x 將總是設定為實(shí)例屬性，并在必要時(shí)創(chuàng )建該實(shí)例屬性。 因此 a.x 的兩次出現不一定指向相同的屬性：如果右側表達式指向一個(gè)類(lèi)屬性，則左側會(huì )創(chuàng )建一個(gè)新的實(shí)例屬性作為賦值的目標:

  class Cls:
      x = 3             # class variable
  inst = Cls()
  inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3
  

  此描述不一定作用于描述器屬性，例如通過(guò) property() 創(chuàng )建的特征屬性。

• 如果目標為一個(gè)抽取項：引用中的原型表達式會(huì )被求值。 它應當產(chǎn)生一個(gè)可變序列對象（例如列表）或一個(gè)映射對象（例如字典）。 接下來(lái)，該抽取表達式會(huì )被求值。

  如果原型為一個(gè)可變序列對象（例如列表），抽取應產(chǎn)生一個(gè)整數。 如其為負值，則再加上序列長(cháng)度。 結果值必須為一個(gè)小于序列長(cháng)度的非負整數，序列將把被賦值對象賦值給該整數指定索引號的項。 如果索引超出范圍，將會(huì )引發(fā) IndexError (給被抽取序列賦值不能向列表添加新項)。

  如果原型為一個(gè)映射對象（例如字典），抽取必須具有與該映射的鍵類(lèi)型相兼容的類(lèi)型，然后映射中會(huì )創(chuàng )建一個(gè)將抽取映射到被賦值對象的鍵/值對。 這可以是替換一個(gè)現有鍵/值對并保持相同鍵值，也可以是插入一個(gè)新鍵/值對（如果具有相同值的鍵不存在）。

  對于用戶(hù)定義對象，會(huì )調用 __setitem__() 方法并附帶適當的參數。

• 如果目標為一個(gè)切片：引用中的原型表達式會(huì )被求值。 它應當產(chǎn)生一個(gè)可變序列對象（例如列表）。 被賦值對象應當是一個(gè)相同類(lèi)型的序列對象。 接下來(lái)，下界與上界表達式如果存在的話(huà)將被求值；默認值分別為零和序列長(cháng)度。 上下邊界值應當為整數。 如果某一邊界為負值，則會(huì )加上序列長(cháng)度。 求出的邊界會(huì )被裁剪至介于零和序列長(cháng)度的開(kāi)區間中。 最后，將要求序列對象以被賦值序列的項替換該切片。 切片的長(cháng)度可能與被賦值序列的長(cháng)度不同，這會(huì )在目標序列允許的情況下改變目標序列的長(cháng)度。

雖然賦值的定義意味著(zhù)左手邊與右手邊的重疊是“同時(shí)”進(jìn)行的（例如 a, b = b, a 會(huì )交換兩個(gè)變量的值），但在賦值給變量的多項集 之內 的重疊是從左至右進(jìn)行的，這有時(shí)會(huì )令人混淆。 例如，以下程序將會(huì )打印出 [0, 2]:

x = [0, 1]
i = 0
i, x[i] = 1, 2         # i is updated, then x[i] is updated
print(x)

augmented_assignment_stmt ::=  augtarget augop (expression_list | yield_expression)
augtarget                 ::=  identifier | attributeref | subscription | slicing
augop                     ::=  "+=" | "-=" | "*=" | "@=" | "/=" | "http://=" | "%=" | "**="
                               | ">>=" | "<<=" | "&=" | "^=" | "|="

annotated_assignment_stmt ::=  augtarget ":" expression
                               ["=" (starred_expression | yield_expression)]

7.3. assert 語(yǔ)句?

assert 語(yǔ)句是在程序中插入調試性斷言的簡(jiǎn)便方式:

assert_stmt ::=  "assert" expression ["," expression]

簡(jiǎn)單形式 assert expression 等價(jià)于

if __debug__:
    if not expression: raise AssertionError

擴展形式 assert expression1, expression2 等價(jià)于

if __debug__:
    if not expression1: raise AssertionError(expression2)

以上等價(jià)形式假定 __debug__ 和 AssertionError 指向具有指定名稱(chēng)的內置變量。 在當前實(shí)現中，內置變量 __debug__ 在正常情況下為 True，在請求優(yōu)化時(shí)為 False (對應命令行選項為 -O)。 如果在編譯時(shí)請求優(yōu)化，當前代碼生成器不會(huì )為 assert 語(yǔ)句發(fā)出任何代碼。 請注意不必在錯誤信息中包含失敗表達式的源代碼；它會(huì )被作為棧追蹤的一部分被顯示。

賦值給 __debug__ 是非法的。 該內置變量的值會(huì )在解釋器啟動(dòng)時(shí)確定。

7.4. pass 語(yǔ)句?

pass_stmt ::=  "pass"

pass 是一個(gè)空操作 --- 當它被執行時(shí)，什么都不發(fā)生。 它適合當語(yǔ)法上需要一條語(yǔ)句但并不需要執行任何代碼時(shí)用來(lái)臨時(shí)占位，例如:

def f(arg): pass    # a function that does nothing (yet)

class C: pass       # a class with no methods (yet)

7.5. del 語(yǔ)句?

del_stmt ::=  "del" target_list

刪除是遞歸定義的，與賦值的定義方式非常類(lèi)似。 此處不再詳細說(shuō)明，只給出一些提示。

目標列表的刪除將從左至右遞歸地刪除每一個(gè)目標。

名稱(chēng)的刪除將從局部或全局命名空間中移除該名稱(chēng)的綁定，具體作用域的確定是看該名稱(chēng)是否有在同一代碼塊的 global 語(yǔ)句中出現。 如果該名稱(chēng)未被綁定，將會(huì )引發(fā) NameError。

屬性引用、抽取和切片的刪除會(huì )被傳遞給相應的原型對象；刪除一個(gè)切片基本等價(jià)于賦值為一個(gè)右側類(lèi)型的空切片（但即便這一點(diǎn)也是由切片對象決定的）。

7.6. return 語(yǔ)句?

return_stmt ::=  "return" [expression_list]

return 在語(yǔ)法上只會(huì )出現于函數定義所嵌套的代碼，不會(huì )出現于類(lèi)定義所嵌套的代碼。

如果提供了表達式列表，它將被求值，否則以 None 替代。

return 會(huì )離開(kāi)當前函數調用，并以表達式列表 (或 None) 作為返回值。

當 return 將控制流傳出一個(gè)帶有 finally 子句的 try 語(yǔ)句時(shí)，該 finally 子句會(huì )先被執行然后再真正離開(kāi)該函數。

在一個(gè)生成器函數中，return 語(yǔ)句表示生成器已完成并將導致 StopIteration 被引發(fā)。 返回值（如果有的話(huà)）會(huì )被當作一個(gè)參數用來(lái)構建 StopIteration 并成為 StopIteration.value 屬性。

在一個(gè)異步生成器函數中，一個(gè)空的 return 語(yǔ)句表示異步生成器已完成并將導致 StopAsyncIteration 被引發(fā)。 一個(gè)非空的 return 語(yǔ)句在異步生成器函數中會(huì )導致語(yǔ)法錯誤。

7.7. yield 語(yǔ)句?

yield_stmt ::=  yield_expression

yield 語(yǔ)句在語(yǔ)義上等同于 yield 表達式。 yield 語(yǔ)句可用來(lái)省略在使用等效的 yield 表達式語(yǔ)句時(shí)所必須的圓括號。 例如，以下 yield 語(yǔ)句

yield <expr>
yield from <expr>

等同于以下 yield 表達式語(yǔ)句

(yield <expr>)
(yield from <expr>)

yield 表達式和語(yǔ)句僅在定義 generator 函數時(shí)使用，并且僅被用于生成器函數的函數體內部。 在函數定義中使用 yield 就足以使得該定義創(chuàng )建的是生成器函數而非普通函數。

有關(guān) yield 語(yǔ)義的完整細節請參看 yield 表達式 一節。

7.8. raise 語(yǔ)句?

raise_stmt ::=  "raise" [expression ["from" expression]]

If no expressions are present, raise re-raises the exception that is currently being handled, which is also known as the active exception. If there isn't currently an active exception, a RuntimeError exception is raised indicating that this is an error.

否則的話(huà)，raise 會(huì )將第一個(gè)表達式求值為異常對象。 它必須為 BaseException 的子類(lèi)或實(shí)例。 如果它是一個(gè)類(lèi)，當需要時(shí)會(huì )通過(guò)不帶參數地實(shí)例化該類(lèi)來(lái)獲得異常的實(shí)例。

異常的 類(lèi)型 為異常實(shí)例的類(lèi)，值 為實(shí)例本身。

A traceback object is normally created automatically when an exception is raised and attached to it as the __traceback__ attribute, which is writable. You can create an exception and set your own traceback in one step using the with_traceback() exception method (which returns the same exception instance, with its traceback set to its argument), like so:

raise Exception("foo occurred").with_traceback(tracebackobj)

from 子句用于異常串連：如果有該子句，則第二個(gè) 表達式 必須為另一個(gè)異常類(lèi)或實(shí)例。 如果第二個(gè)表達式是一個(gè)異常實(shí)例，它將作為可寫(xiě)的 __cause__ 屬性被關(guān)聯(lián)到所引發(fā)的異常。 如果該表達式是一個(gè)異常類(lèi)，這個(gè)類(lèi)將被實(shí)例化且所生成的異常實(shí)例將作為 __cause__ 屬性被關(guān)聯(lián)到所引發(fā)的異常。 如果所引發(fā)的異常未被處理，則兩個(gè)異常都將被打印出來(lái):

>>> try:
...     print(1 / 0)
... except Exception as exc:
...     raise RuntimeError("Something bad happened") from exc
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
ZeroDivisionError: division by zero

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError: Something bad happened

A similar mechanism works implicitly if a new exception is raised when an exception is already being handled. An exception may be handled when an except or finally clause, or a with statement, is used. The previous exception is then attached as the new exception's __context__ attribute:

>>> try:
...     print(1 / 0)
... except:
...     raise RuntimeError("Something bad happened")
...
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
ZeroDivisionError: division by zero

During handling of the above exception, another exception occurred:

Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError: Something bad happened

異常串連可通過(guò)在 from 子句中指定 None 來(lái)顯式地加以抑制:

>>> try:
...     print(1 / 0)
... except:
...     raise RuntimeError("Something bad happened") from None
...
Traceback (most recent call last):
  File "<stdin>", line 4, in <module>
RuntimeError: Something bad happened

有關(guān)異常的更多信息可在 異常 一節查看，有關(guān)處理異常的信息可在 try 語(yǔ)句 一節查看。

7.9. break 語(yǔ)句?

break_stmt ::=  "break"

break 在語(yǔ)法上只會(huì )出現于 for 或 while 循環(huán)所嵌套的代碼，但不會(huì )出現于該循環(huán)內部的函數或類(lèi)定義所嵌套的代碼。

它會(huì )終結最近的外層循環(huán)，如果循環(huán)有可選的 else 子句，也會(huì )跳過(guò)該子句。

如果一個(gè) for 循環(huán)被 break 所終結，該循環(huán)的控制目標會(huì )保持其當前值。

當 break 將控制流傳出一個(gè)帶有 finally 子句的 try 語(yǔ)句時(shí)，該 finally 子句會(huì )先被執行然后再真正離開(kāi)該循環(huán)。

7.10. continue 語(yǔ)句?

continue_stmt ::=  "continue"

continue 在語(yǔ)法上只會(huì )出現于 for 或 while 循環(huán)所嵌套的代碼中，但不會(huì )出現于該循環(huán)內部的函數或類(lèi)定義中。 它會(huì )繼續執行最近的外層循環(huán)的下一個(gè)輪次。

當 continue 將控制流傳出一個(gè)帶有 finally 子句的 try 語(yǔ)句時(shí)，該 finally 子句會(huì )先被執行然后再真正開(kāi)始循環(huán)的下一個(gè)輪次。

7.11. import 語(yǔ)句?

import_stmt     ::=  "import" module ["as" identifier] ("," module ["as" identifier])*
                     | "from" relative_module "import" identifier ["as" identifier]
                     ("," identifier ["as" identifier])*
                     | "from" relative_module "import" "(" identifier ["as" identifier]
                     ("," identifier ["as" identifier])* [","] ")"
                     | "from" relative_module "import" "*"
module          ::=  (identifier ".")* identifier
relative_module ::=  "."* module | "."+

基本的 import 語(yǔ)句（不帶 from 子句）會(huì )分兩步執行:

1. 查找一個(gè)模塊，如果有必要還會(huì )加載并初始化模塊。

2. 在局部命名空間中為 import 語(yǔ)句發(fā)生位置所處的作用域定義一個(gè)或多個(gè)名稱(chēng)。

當語(yǔ)句包含多個(gè)子句（由逗號分隔）時(shí)這兩個(gè)步驟將對每個(gè)子句分別執行，如同這些子句被分成獨立的 import 語(yǔ)句一樣。

第一個(gè)步驟即查找和加載模塊的詳情 導入系統 一節中有更詳細的描述，其中也描述了可被導入的多種類(lèi)型的包和模塊，以及可用于定制導入系統的所有鉤子對象。 請注意這一步如果失敗，則可能說(shuō)明模塊無(wú)法找到，或者 是在初始化模塊，包括執行模塊代碼期間發(fā)生了錯誤。

如果成功獲取到請求的模塊，則可以通過(guò)以下三種方式一之在局部命名空間中使用它:

• 模塊名后使用 as 時(shí)，直接把 as 后的名稱(chēng)與導入模塊綁定。

• 如果沒(méi)有指定其他名稱(chēng)，且被導入的模塊為最高層級模塊，則模塊的名稱(chēng)將被綁定到局部命名空間作為對所導入模塊的引用。

• 如果被導入的模塊 不是 最高層級模塊，則包含該模塊的最高層級包的名稱(chēng)將被綁定到局部命名空間作為對該最高層級包的引用。 所導入的模塊必須使用其完整限定名稱(chēng)來(lái)訪(fǎng)問(wèn)而不能直接訪(fǎng)問(wèn)。

from 形式使用的過(guò)程略微繁復一些:

1. 查找 from 子句中指定的模塊，如有必要還會(huì )加載并初始化模塊；

2. 對于 import 子句中指定的每個(gè)標識符：

   1. 檢查被導入模塊是否有該名稱(chēng)的屬性

   2. 如果沒(méi)有，嘗試導入具有該名稱(chēng)的子模塊，然后再次檢查被導入模塊是否有該屬性

   3. 如果未找到該屬性，則引發(fā) ImportError。

   4. 否則的話(huà)，將對該值的引用存入局部命名空間，如果有 as 子句則使用其指定的名稱(chēng)，否則使用該屬性的名稱(chēng)

示例:

import foo                 # foo imported and bound locally
import foo.bar.baz         # foo, foo.bar, and foo.bar.baz imported, foo bound locally
import foo.bar.baz as fbb  # foo, foo.bar, and foo.bar.baz imported, foo.bar.baz bound as fbb
from foo.bar import baz    # foo, foo.bar, and foo.bar.baz imported, foo.bar.baz bound as baz
from foo import attr       # foo imported and foo.attr bound as attr

如果標識符列表改為一個(gè)星號 ('*')，則在模塊中定義的全部公有名稱(chēng)都將按 import 語(yǔ)句所在的作用域被綁定到局部命名空間。

一個(gè)模塊所定義的 公有名稱(chēng) 是由在模塊的命名空間中檢測一個(gè)名為 __all__ 的變量來(lái)確定的；如果有定義，它必須是一個(gè)字符串列表，其中的項為該模塊所定義或導入的名稱(chēng)。 在 __all__ 中所給出的名稱(chēng)都會(huì )被視為公有并且應當存在。 如果 __all__ 沒(méi)有被定義，則公有名稱(chēng)的集合將包含在模塊的命名空間中找到的所有不以下劃線(xiàn)字符 ('_') 打頭的名稱(chēng)。 __all__ 應當包括整個(gè)公有 API。 它的目標是避免意外地導出不屬于 API 的一部分的項（例如在模塊內部被導入和使用的庫模塊）。

通配符形式的導入 --- from module import * --- 僅在模塊層級上被允許。 嘗試在類(lèi)或函數定義中使用它將引發(fā) SyntaxError。

當指定要導入哪個(gè)模塊時(shí)，你不必指定模塊的絕對名稱(chēng)。 當一個(gè)模塊或包被包含在另一個(gè)包之中時(shí)，可以在同一個(gè)最高層級包中進(jìn)行相對導入，而不必提及包名稱(chēng)。 通過(guò)在 from 之后指定的模塊或包中使用前綴點(diǎn)號，你可以在不指定確切名稱(chēng)的情況下指明在當前包層級結構中要上溯多少級。 一個(gè)前綴點(diǎn)號表示是執行導入的模塊所在的當前包，兩個(gè)點(diǎn)號表示上溯一個(gè)包層級。 三個(gè)點(diǎn)號表示上溯兩級，依此類(lèi)推。 因此如果你執行 from . import mod 時(shí)所處位置為 pkg 包內的一個(gè)模塊，則最終你將導入 pkg.mod。 如果你執行 from ..subpkg2 import mod 時(shí)所處位置為 pkg.subpkg1 則你將導入 pkg.subpkg2.mod。 有關(guān)相對導入的規范說(shuō)明包含在 包相對導入 一節中。

importlib.import_module() 被提供用來(lái)為動(dòng)態(tài)地確定要導入模塊的應用提供支持。

引發(fā)一個(gè) 審計事件 import 附帶參數 module, filename, sys.path, sys.meta_path, sys.path_hooks。

future_stmt ::=  "from" "__future__" "import" feature ["as" identifier]
                 ("," feature ["as" identifier])*
                 | "from" "__future__" "import" "(" feature ["as" identifier]
                 ("," feature ["as" identifier])* [","] ")"
feature     ::=  identifier

import __future__ [as name]

7.12. global 語(yǔ)句?

global_stmt ::=  "global" identifier ("," identifier)*

global 語(yǔ)句是作用于整個(gè)當前代碼塊的聲明。 它意味著(zhù)所列出的標識符將被解讀為全局變量。 要給全局變量賦值不可能不用到 global 關(guān)鍵字，不過(guò)自由變量也可以指向全局變量而不必聲明為全局變量。

在 global 語(yǔ)句中列出的名稱(chēng)不得在同一代碼塊內該 global 語(yǔ)句之前的位置中使用。

在 global 語(yǔ)句中列出的名稱(chēng)不能被定義為形式參數，也不能被作為 with 語(yǔ)句或 except 子句的目標，以及 for 循環(huán)的目標列表、class 定義、函數定義、import 語(yǔ)句或變量標注等等。

程序員注意事項: global 是對解析器的指令。 它僅對與 global 語(yǔ)句同時(shí)被解析的代碼起作用。 特別地，包含在提供給內置 exec() 函數字符串或代碼對象中的 global 語(yǔ)句并不會(huì )影響 包含 該函數調用的代碼塊，而包含在這種字符串中的代碼也不會(huì )受到包含該函數調用的代碼中的 global 語(yǔ)句影響。 這同樣適用于 eval() 和 compile() 函數。

7.13. nonlocal 語(yǔ)句?

nonlocal_stmt ::=  "nonlocal" identifier ("," identifier)*

nonlocal 語(yǔ)句會(huì )使得所列出的名稱(chēng)指向之前在最近的包含作用域中綁定的除全局變量以外的變量。 這種功能很重要，因為綁定的默認行為是先搜索局部命名空間。 這個(gè)語(yǔ)句允許被封裝的代碼重新綁定局部作用域以外且非全局（模塊）作用域當中的變量。

與 global 語(yǔ)句中列出的名稱(chēng)不同，nonlocal 語(yǔ)句中列出的名稱(chēng)必須指向之前存在于包含作用域之中的綁定（在這個(gè)應當用來(lái)創(chuàng )建新綁定的作用域不能被無(wú)歧義地確定）。

nonlocal 語(yǔ)句中列出的名稱(chēng)不得與之前存在于局部作用域中的綁定相沖突。