8. 復(fù)合語句?

8.1. if 語句?

if 語句用于有條件的執(zhí)行:

if_stmt ::=  "if" assignment_expression ":" suite
             ("elif" assignment_expression ":" suite)*
             ["else" ":" suite]

它通過對(duì)表達(dá)式逐個(gè)求值直至找到一個(gè)真值（請(qǐng)參閱 布爾運(yùn)算 了解真值與假值的定義）在子句體中選擇唯一匹配的一個(gè)；然后執(zhí)行該子句體（而且 if 語句的其他部分不會(huì)被執(zhí)行或求值）。 如果所有表達(dá)式均為假值，則如果 else 子句體如果存在就會(huì)被執(zhí)行。

8.2. while 語句?

while 語句用于在表達(dá)式保持為真的情況下重復(fù)地執(zhí)行:

while_stmt ::=  "while" assignment_expression ":" suite
                ["else" ":" suite]

這將重復(fù)地檢驗(yàn)表達(dá)式，并且如果其值為真就執(zhí)行第一個(gè)子句體；如果表達(dá)式值為假（這可能在第一次檢驗(yàn)時(shí)就發(fā)生）則如果 else 子句體存在就會(huì)被執(zhí)行并終止循環(huán)。

第一個(gè)子句體中的 break 語句在執(zhí)行時(shí)將終止循環(huán)且不執(zhí)行 else 子句體。 第一個(gè)子句體中的 continue 語句在執(zhí)行時(shí)將跳過子句體中的剩余部分并返回檢驗(yàn)表達(dá)式。

8.3. for 語句?

for 語句用于對(duì)序列（例如字符串、元組或列表）或其他可迭代對(duì)象中的元素進(jìn)行迭代:

for_stmt ::=  "for" target_list "in" starred_list ":" suite
              ["else" ":" suite]

The starred_list expression is evaluated once; it should yield an iterable object. An iterator is created for that iterable. The first item provided by the iterator is then assigned to the target list using the standard rules for assignments (see 賦值語句), and the suite is executed. This repeats for each item provided by the iterator. When the iterator is exhausted, the suite in the else clause, if present, is executed, and the loop terminates.

第一個(gè)子句體中的 break 語句在執(zhí)行時(shí)將終止循環(huán)且不執(zhí)行 else 子句體。 第一個(gè)子句體中的 continue 語句在執(zhí)行時(shí)將跳過子句體中的剩余部分并轉(zhuǎn)往下一項(xiàng)繼續(xù)執(zhí)行，或者在沒有下一項(xiàng)時(shí)轉(zhuǎn)往 else 子句執(zhí)行。

for 循環(huán)會(huì)對(duì)目標(biāo)列表中的變量進(jìn)行賦值。 這將覆蓋之前對(duì)這些變量的所有賦值，包括在 for 循環(huán)體中的賦值:

for i in range(10):
    print(i)
    i = 5             # this will not affect the for-loop
                      # because i will be overwritten with the next
                      # index in the range

目標(biāo)列表中的名稱在循環(huán)結(jié)束時(shí)不會(huì)被刪除，但如果序列為空，則它們根本不會(huì)被循環(huán)所賦值。 提示：內(nèi)置函數(shù) range() 會(huì)返回一個(gè)可迭代的整數(shù)序列，適用于模擬 Pascal 中的 for i := a to b do 這種效果；例如 list(range(3)) 會(huì)返回列表 [0, 1, 2]。

8.4. try 語句?

try 語句可為一組語句指定異常處理器和/或清理代碼:

try_stmt  ::=  try1_stmt | try2_stmt | try3_stmt
try1_stmt ::=  "try" ":" suite
               ("except" [expression ["as" identifier]] ":" suite)+
               ["else" ":" suite]
               ["finally" ":" suite]
try2_stmt ::=  "try" ":" suite
               ("except" "*" expression ["as" identifier] ":" suite)+
               ["else" ":" suite]
               ["finally" ":" suite]
try3_stmt ::=  "try" ":" suite
               "finally" ":" suite

The except clause(s) specify one or more exception handlers. When no exception occurs in the try clause, no exception handler is executed. When an exception occurs in the try suite, a search for an exception handler is started. This search inspects the except clauses in turn until one is found that matches the exception. An expression-less except clause, if present, must be last; it matches any exception. For an except clause with an expression, that expression is evaluated, and the clause matches the exception if the resulting object is "compatible" with the exception. An object is compatible with an exception if the object is the class or a non-virtual base class of the exception object, or a tuple containing an item that is the class or a non-virtual base class of the exception object.

如果沒有 except 子句與異常相匹配，則會(huì)在周邊代碼和發(fā)起調(diào)用棧上繼續(xù)搜索異常處理器。 1

如果在對(duì) except 子句頭中的表達(dá)式求值時(shí)引發(fā)了異常，則原來對(duì)處理器的搜索會(huì)被取消，并在周邊代碼和調(diào)用棧上啟動(dòng)對(duì)新異常的搜索（它會(huì)被視作是整個(gè) try 語句所引發(fā)的異常）。

當(dāng)找到一個(gè)匹配的 except 子句時(shí)，該異常將被賦值給該 except 子句在 as 關(guān)鍵字之后指定的目標(biāo)，如果存在此關(guān)鍵字的話，并且該 except 子句體將被執(zhí)行。 所有 except 子句都必須有可執(zhí)行的子句體。 當(dāng)?shù)竭_(dá)子句體的末尾時(shí)，通常會(huì)轉(zhuǎn)向整個(gè) try 語句之后繼續(xù)執(zhí)行。 （這意味著如果對(duì)于同一異常存在有嵌套的兩個(gè)處理器，而異常發(fā)生于內(nèi)層處理器的 try 子句中，則外層處理器將不會(huì)處理該異常。）

當(dāng)使用 as 將目標(biāo)賦值為一個(gè)異常時(shí)，它將在 except 子句結(jié)束時(shí)被清除。 這就相當(dāng)于

except E as N:
    foo

被轉(zhuǎn)寫為

except E as N:
    try:
        foo
    finally:
        del N

這意味著異常必須賦值給一個(gè)不同的名稱才能在 except 子句之后引用它。 異常會(huì)被清除是因?yàn)樵诟郊恿嘶厮菪畔⒌那闆r下，它們會(huì)形成堆棧幀的循環(huán)引用，使得所有局部變量保持存活直到發(fā)生下一次垃圾回收。

在一個(gè) except 子句體被執(zhí)行之前，有關(guān)異常的詳細(xì)信息存放在 sys 模塊中，可通過 sys.exc_info() 來訪問。 sys.exc_info() 返回一個(gè) 3 元組，由異常類、異常實(shí)例和回溯對(duì)象組成（參見 標(biāo)準(zhǔn)類型層級(jí)結(jié)構(gòu) 一節(jié)），用于在程序中標(biāo)識(shí)異常發(fā)生點(diǎn)。 當(dāng)從處理異常的代碼返回時(shí)，通過 sys.exc_info() 訪問的異常詳細(xì)信息會(huì)恢復(fù)到之前的值:

>>> print(sys.exc_info())
(None, None, None)
>>> try:
...     raise TypeError
... except:
...     print(sys.exc_info())
...     try:
...          raise ValueError
...     except:
...         print(sys.exc_info())
...     print(sys.exc_info())
...
(<class 'TypeError'>, TypeError(), <traceback object at 0x10efad080>)
(<class 'ValueError'>, ValueError(), <traceback object at 0x10efad040>)
(<class 'TypeError'>, TypeError(), <traceback object at 0x10efad080>)
>>> print(sys.exc_info())
(None, None, None)

The except* clause(s) are used for handling ExceptionGroups. The exception type for matching is interpreted as in the case of except, but in the case of exception groups we can have partial matches when the type matches some of the exceptions in the group. This means that multiple except* clauses can execute, each handling part of the exception group. Each clause executes once and handles an exception group of all matching exceptions. Each exception in the group is handled by at most one except* clause, the first that matches it.

>>> try:
...     raise ExceptionGroup("eg",
...         [ValueError(1), TypeError(2), OSError(3), OSError(4)])
... except* TypeError as e:
...     print(f'caught {type(e)} with nested {e.exceptions}')
... except* OSError as e:
...     print(f'caught {type(e)} with nested {e.exceptions}')
...
caught <class 'ExceptionGroup'> with nested (TypeError(2),)
caught <class 'ExceptionGroup'> with nested (OSError(3), OSError(4))
  + Exception Group Traceback (most recent call last):
  |   File "<stdin>", line 2, in <module>
  | ExceptionGroup: eg
  +-+---------------- 1 ----------------
    | ValueError: 1
    +------------------------------------
>>>

Any remaining exceptions that were not handled by any except* clause
are re-raised at the end, combined into an exception group along with
all exceptions that were raised from within except* clauses.

An except* clause must have a matching type, and this type cannot be a
subclass of :exc:`BaseExceptionGroup`. It is not possible to mix except
and except* in the same :keyword:`try`. :keyword:`break`,
:keyword:`continue` and :keyword:`return` cannot appear in an except*
clause.

如果控制流離開 try 子句體時(shí)沒有引發(fā)異常，并且沒有執(zhí)行 return, continue 或 break 語句，可選的 else 子句將被執(zhí)行。 else 語句中的異常不會(huì)由之前的 except 子句處理。

如果存在 finally，它將指定一個(gè)‘清理’處理程序。 try 子句會(huì)被執(zhí)行，包括任何 except 和 else 子句。 如果在這些子句中發(fā)生任何未處理的異常，該異常會(huì)被臨時(shí)保存。 finally 子句將被執(zhí)行。 如果存在被保存的異常，它會(huì)在 finally 子句的末尾被重新引發(fā)。 如果 finally 子句引發(fā)了另一個(gè)異常，被保存的異常會(huì)被設(shè)為新異常的上下文。 如果 finally 子句執(zhí)行了 return, break 或 continue 語句，則被保存的異常會(huì)被丟棄:

>>> def f():
...     try:
...         1/0
...     finally:
...         return 42
...
>>> f()
42

在 finally 子句執(zhí)行期間，程序不能獲取異常信息。

當(dāng) return, break 或 continue 語句在一個(gè) try...finally 語句的 try 子語句體中被執(zhí)行時(shí)，finally 子語句也會(huì)‘在離開時(shí)’被執(zhí)行。

函數(shù)的返回值是由最后被執(zhí)行的 return 語句所決定的。 由于 finally 子句總是被執(zhí)行，因此在 finally 子句中被執(zhí)行的 return 語句總是最后被執(zhí)行的:

>>> def foo():
...     try:
...         return 'try'
...     finally:
...         return 'finally'
...
>>> foo()
'finally'

有關(guān)異常的更多信息可以在 異常 一節(jié)找到，有關(guān)使用 raise 語句生成異常的信息可以在 raise 語句 一節(jié)找到。

8.5. with 語句?

with 語句用于包裝帶有使用上下文管理器 (參見 with 語句上下文管理器 一節(jié)) 定義的方法的代碼塊的執(zhí)行。 這允許對(duì)普通的 try...except...finally 使用模式進(jìn)行封裝以方便地重用。

with_stmt          ::=  "with" ( "(" with_stmt_contents ","? ")" | with_stmt_contents ) ":" suite
with_stmt_contents ::=  with_item ("," with_item)*
with_item          ::=  expression ["as" target]

帶有一個(gè)“項(xiàng)目”的 with 語句的執(zhí)行過程如下:

1. The context expression (the expression given in the with_item) is evaluated to obtain a context manager.

2. 載入上下文管理器的 __enter__() 以便后續(xù)使用。

3. 載入上下文管理器的 __exit__() 以便后續(xù)使用。

4. 發(fā)起調(diào)用上下文管理器的 __enter__() 方法。

5. 如果 with 語句中包含一個(gè)目標(biāo)，來自 __enter__() 的返回值將被賦值給它。

   備注

   with 語句會(huì)保證如果 __enter__() 方法返回時(shí)未發(fā)生錯(cuò)誤，則 __exit__() 將總是被調(diào)用。 因此，如果在對(duì)目標(biāo)列表賦值期間發(fā)生錯(cuò)誤，則會(huì)將其視為在語句體內(nèi)部發(fā)生的錯(cuò)誤。 參見下面的第 6 步。

6. 執(zhí)行語句體。

7. 發(fā)起調(diào)用上下文管理器的 __exit__() 方法。 如果語句體的退出是由異常導(dǎo)致的，則其類型、值和回溯信息將被作為參數(shù)傳遞給 __exit__()。 否則的話，將提供三個(gè) None 參數(shù)。

   如果語句體的退出是由異常導(dǎo)致的，并且來自 __exit__() 方法的返回值為假，則該異常會(huì)被重新引發(fā)。 如果返回值為真，則該異常會(huì)被抑制，并會(huì)繼續(xù)執(zhí)行 with 語句之后的語句。

   如果語句體由于異常以外的任何原因退出，則來自 __exit__() 的返回值會(huì)被忽略，并會(huì)在該類退出正常的發(fā)生位置繼續(xù)執(zhí)行。

以下代碼:

with EXPRESSION as TARGET:
    SUITE

在語義上等價(jià)于:

manager = (EXPRESSION)
enter = type(manager).__enter__
exit = type(manager).__exit__
value = enter(manager)
hit_except = False

try:
    TARGET = value
    SUITE
except:
    hit_except = True
    if not exit(manager, *sys.exc_info()):
        raise
finally:
    if not hit_except:
        exit(manager, None, None, None)

如果有多個(gè)項(xiàng)目，則會(huì)視作存在多個(gè) with 語句嵌套來處理多個(gè)上下文管理器:

with A() as a, B() as b:
    SUITE

在語義上等價(jià)于:

with A() as a:
    with B() as b:
        SUITE

也可以用圓括號(hào)包圍的多行形式的多項(xiàng)目上下文管理器。例如:

with (
    A() as a,
    B() as b,
):
    SUITE

8.6. match 語句?

匹配語句用于進(jìn)行模式匹配。語法如下：

match_stmt   ::=  'match' subject_expr ":" NEWLINE INDENT case_block+ DEDENT
subject_expr ::=  star_named_expression "," star_named_expressions?
                  | named_expression
case_block   ::=  'case' patterns [guard] ":" block

模式匹配接受一個(gè)模式作為輸入（跟在 case 后），一個(gè)主詞值（跟在 match 后）。該模式（可能包含子模式）與主題值進(jìn)行匹配。輸出是：

• 匹配成功或失?。ㄒ脖环Q為模式成功或失?。?。

• 可能將匹配的值綁定到一個(gè)名字上。 這方面的先決條件將在下面進(jìn)一步討論。

關(guān)鍵字 match 和 case 是 soft keywords 。

>>> flag = False
>>> match (100, 200):
...    case (100, 300):  # Mismatch: 200 != 300
...        print('Case 1')
...    case (100, 200) if flag:  # Successful match, but guard fails
...        print('Case 2')
...    case (100, y):  # Matches and binds y to 200
...        print(f'Case 3, y: {y}')
...    case _:  # Pattern not attempted
...        print('Case 4, I match anything!')
...
Case 3, y: 200

guard ::=  "if" named_expression

patterns       ::=  open_sequence_pattern | pattern
pattern        ::=  as_pattern | or_pattern
closed_pattern ::=  | literal_pattern
                    | capture_pattern
                    | wildcard_pattern
                    | value_pattern
                    | group_pattern
                    | sequence_pattern
                    | mapping_pattern
                    | class_pattern

or_pattern ::=  "|".closed_pattern+

as_pattern ::=  or_pattern "as" capture_pattern

literal_pattern ::=  signed_number
                     | signed_number "+" NUMBER
                     | signed_number "-" NUMBER
                     | strings
                     | "None"
                     | "True"
                     | "False"
                     | signed_number: NUMBER | "-" NUMBER

capture_pattern ::=  !'_' NAME

wildcard_pattern ::=  '_'

value_pattern ::=  attr
attr          ::=  name_or_attr "." NAME
name_or_attr  ::=  attr | NAME

group_pattern ::=  "(" pattern ")"

sequence_pattern       ::=  "[" [maybe_sequence_pattern] "]"
                            | "(" [open_sequence_pattern] ")"
open_sequence_pattern  ::=  maybe_star_pattern "," [maybe_sequence_pattern]
maybe_sequence_pattern ::=  ",".maybe_star_pattern+ ","?
maybe_star_pattern     ::=  star_pattern | pattern
star_pattern           ::=  "*" (capture_pattern | wildcard_pattern)

mapping_pattern     ::=  "{" [items_pattern] "}"
items_pattern       ::=  ",".key_value_pattern+ ","?
key_value_pattern   ::=  (literal_pattern | value_pattern) ":" pattern
                         | double_star_pattern
double_star_pattern ::=  "**" capture_pattern

class_pattern       ::=  name_or_attr "(" [pattern_arguments ","?] ")"
pattern_arguments   ::=  positional_patterns ["," keyword_patterns]
                         | keyword_patterns
positional_patterns ::=  ",".pattern+
keyword_patterns    ::=  ",".keyword_pattern+
keyword_pattern     ::=  NAME "=" pattern

8.7. 函數(shù)定義?

函數(shù)定義就是對(duì)用戶自定義函數(shù)的定義（參見 標(biāo)準(zhǔn)類型層級(jí)結(jié)構(gòu) 一節(jié)）:

funcdef                   ::=  [decorators] "def" funcname "(" [parameter_list] ")"
                               ["->" expression] ":" suite
decorators                ::=  decorator+
decorator                 ::=  "@" assignment_expression NEWLINE
parameter_list            ::=  defparameter ("," defparameter)* "," "/" ["," [parameter_list_no_posonly]]
                                 | parameter_list_no_posonly
parameter_list_no_posonly ::=  defparameter ("," defparameter)* ["," [parameter_list_starargs]]
                               | parameter_list_starargs
parameter_list_starargs   ::=  "*" [parameter] ("," defparameter)* ["," ["**" parameter [","]]]
                               | "**" parameter [","]
parameter                 ::=  identifier [":" expression]
defparameter              ::=  parameter ["=" expression]
funcname                  ::=  identifier

函數(shù)定義是一條可執(zhí)行語句。 它執(zhí)行時(shí)會(huì)在當(dāng)前局部命名空間中將函數(shù)名稱綁定到一個(gè)函數(shù)對(duì)象（函數(shù)可執(zhí)行代碼的包裝器）。 這個(gè)函數(shù)對(duì)象包含對(duì)當(dāng)前全局命名空間的引用，作為函數(shù)被調(diào)用時(shí)所使用的全局命名空間。

函數(shù)定義并不會(huì)執(zhí)行函數(shù)體；只有當(dāng)函數(shù)被調(diào)用時(shí)才會(huì)執(zhí)行此操作。 4

一個(gè)函數(shù)定義可以被一個(gè)或多個(gè) decorator 表達(dá)式所包裝。 當(dāng)函數(shù)被定義時(shí)將在包含該函數(shù)定義的作用域中對(duì)裝飾器表達(dá)式求值。 求值結(jié)果必須是一個(gè)可調(diào)用對(duì)象，它會(huì)以該函數(shù)對(duì)象作為唯一參數(shù)被發(fā)起調(diào)用。 其返回值將被綁定到函數(shù)名稱而非函數(shù)對(duì)象。 多個(gè)裝飾器會(huì)以嵌套方式被應(yīng)用。 例如以下代碼

@f1(arg)
@f2
def func(): pass

大致等價(jià)于

def func(): pass
func = f1(arg)(f2(func))

不同之處在于原始函數(shù)并不會(huì)被臨時(shí)綁定到名稱 func。

當(dāng)一個(gè)或多個(gè) 形參 具有 形參 = 表達(dá)式 這樣的形式時(shí)，該函數(shù)就被稱為具有“默認(rèn)形參值”。 對(duì)于一個(gè)具有默認(rèn)值的形參，其對(duì)應(yīng)的 argument 可以在調(diào)用中被省略，在此情況下會(huì)用形參的默認(rèn)值來替代。 如果一個(gè)形參具有默認(rèn)值，后續(xù)所有在 "*" 之前的形參也必須具有默認(rèn)值 --- 這個(gè)句法限制并未在語法中明確表達(dá)。

默認(rèn)形參值會(huì)在執(zhí)行函數(shù)定義時(shí)按從左至右的順序被求值。 這意味著當(dāng)函數(shù)被定義時(shí)將對(duì)表達(dá)式求值一次，相同的“預(yù)計(jì)算”值將在每次調(diào)用時(shí)被使用。 這一點(diǎn)在默認(rèn)形參為可變對(duì)象，例如列表或字典的時(shí)候尤其需要重點(diǎn)理解：如果函數(shù)修改了該對(duì)象（例如向列表添加了一項(xiàng)），則實(shí)際上默認(rèn)值也會(huì)被修改。 這通常不是人們所想要的。 繞過此問題的一個(gè)方法是使用 None 作為默認(rèn)值，并在函數(shù)體中顯式地對(duì)其進(jìn)測(cè)試，例如:

def whats_on_the_telly(penguin=None):
    if penguin is None:
        penguin = []
    penguin.append("property of the zoo")
    return penguin

函數(shù)調(diào)用的語義在 調(diào)用 一節(jié)中有更詳細(xì)的描述。 函數(shù)調(diào)用總是會(huì)給形參列表中列出的所有形參賦值，或是用位置參數(shù)，或是用關(guān)鍵字參數(shù)，或是用默認(rèn)值。 如果存在 "*identifier" 這樣的形式，它會(huì)被初始化為一個(gè)元組來接收任何額外的位置參數(shù)，默認(rèn)為一個(gè)空元組。 如果存在 "**identifier" 這樣的形式，它會(huì)被初始化為一個(gè)新的有序映射來接收任何額外的關(guān)鍵字參數(shù)，默認(rèn)為一個(gè)相同類型的空映射。 在 "*" 或 "*identifier" 之后的形參都是僅限關(guān)鍵字形參因而只能通過關(guān)鍵字參數(shù)傳入。 在 "/" 之前的形參都是僅限位置形參因而只能通過位置參數(shù)傳入。

形參可以帶有 標(biāo)注，其形式為在形參名稱后加上 ": expression"。 任何形參都可以帶有標(biāo)注，甚至 *identifier 或 **identifier 這樣的形參也可以。 函數(shù)可以帶有“返回”標(biāo)注，其形式為在形參列表后加上 "-> expression"。 這些標(biāo)注可以是任何有效的 Python 表達(dá)式。 標(biāo)注的存在不會(huì)改變函數(shù)的語義。 標(biāo)注值可以作為函數(shù)對(duì)象的 __annotations__ 屬性中以對(duì)應(yīng)形參名稱為鍵的字典值被訪問。 如果使用了 annotations import from __future__ 的方式，則標(biāo)注會(huì)在運(yùn)行時(shí)保存為字符串以啟用延遲求值特性。 否則，它們會(huì)在執(zhí)行函數(shù)定義時(shí)被求值。 在這種情況下，標(biāo)注的求值順序可能與它們?cè)谠创a中出現(xiàn)的順序不同。

創(chuàng)建匿名函數(shù)（未綁定到一個(gè)名稱的函數(shù)）以便立即在表達(dá)式中使用也是可能的。 這需要使用 lambda 表達(dá)式，具體描述見 lambda 表達(dá)式 一節(jié)。 請(qǐng)注意 lambda 只是簡(jiǎn)單函數(shù)定義的一種簡(jiǎn)化寫法；在 "def" 語句中定義的函數(shù)也可以像用 lambda 表達(dá)式定義的函數(shù)一樣被傳遞或賦值給其他名稱。 "def" 形式實(shí)際上更為強(qiáng)大，因?yàn)樗试S執(zhí)行多條語句和使用標(biāo)注。

程序員注意事項(xiàng): 函數(shù)屬于一類對(duì)象。 在一個(gè)函數(shù)內(nèi)部執(zhí)行的 "def" 語句會(huì)定義一個(gè)局部函數(shù)并可被返回或傳遞。 在嵌套函數(shù)中使用的自由變量可以訪問包含該 def 語句的函數(shù)的局部變量。 詳情參見 命名與綁定 一節(jié)。

8.8. 類定義?

類定義就是對(duì)類對(duì)象的定義 (參見 標(biāo)準(zhǔn)類型層級(jí)結(jié)構(gòu) 一節(jié)):

classdef    ::=  [decorators] "class" classname [inheritance] ":" suite
inheritance ::=  "(" [argument_list] ")"
classname   ::=  identifier

類定義是一條可執(zhí)行語句。 其中繼承列表通常給出基類的列表 (進(jìn)階用法請(qǐng)參見 元類)，列表中的每一項(xiàng)都應(yīng)當(dāng)被求值為一個(gè)允許子類的類對(duì)象。 沒有繼承列表的類默認(rèn)繼承自基類 object；因此，:

class Foo:
    pass

等價(jià)于

class Foo(object):
    pass

隨后類體將在一個(gè)新的執(zhí)行幀 (參見 命名與綁定) 中被執(zhí)行，使用新創(chuàng)建的局部命名空間和原有的全局命名空間。 （通常，類體主要包含函數(shù)定義。） 當(dāng)類體結(jié)束執(zhí)行時(shí)，其執(zhí)行幀將被丟棄而其局部命名空間會(huì)被保存。 5 一個(gè)類對(duì)象隨后會(huì)被創(chuàng)建，其基類使用給定的繼承列表，屬性字典使用保存的局部命名空間。 類名稱將在原有的全局命名空間中綁定到該類對(duì)象。

在類體內(nèi)定義的屬性的順序保存在新類的 __dict__ 中。 請(qǐng)注意此順序的可靠性只限于類剛被創(chuàng)建時(shí)，并且只適用于使用定義語法所定義的類。

類的創(chuàng)建可使用 元類 進(jìn)行重度定制。

類也可以被裝飾：就像裝飾函數(shù)一樣，:

@f1(arg)
@f2
class Foo: pass

大致等價(jià)于

class Foo: pass
Foo = f1(arg)(f2(Foo))

裝飾器表達(dá)式的求值規(guī)則與函數(shù)裝飾器相同。 結(jié)果隨后會(huì)被綁定到類名稱。

程序員注意事項(xiàng): 在類定義內(nèi)定義的變量是類屬性；它們將被類實(shí)例所共享。 實(shí)例屬性可通過 self.name = value 在方法中設(shè)定。 類和實(shí)例屬性均可通過 "self.name" 表示法來訪問，當(dāng)通過此方式訪問時(shí)實(shí)例屬性會(huì)隱藏同名的類屬性。 類屬性可被用作實(shí)例屬性的默認(rèn)值，但在此場(chǎng)景下使用可變值可能導(dǎo)致未預(yù)期的結(jié)果。 可以使用 描述器 來創(chuàng)建具有不同實(shí)現(xiàn)細(xì)節(jié)的實(shí)例變量。

8.9. 協(xié)程?

async_funcdef ::=  [decorators] "async" "def" funcname "(" [parameter_list] ")"
                   ["->" expression] ":" suite

async def func(param1, param2):
    do_stuff()
    await some_coroutine()

async_for_stmt ::=  "async" for_stmt

async for TARGET in ITER:
    SUITE
else:
    SUITE2

iter = (ITER)
iter = type(iter).__aiter__(iter)
running = True

while running:
    try:
        TARGET = await type(iter).__anext__(iter)
    except StopAsyncIteration:
        running = False
    else:
        SUITE
else:
    SUITE2

async_with_stmt ::=  "async" with_stmt

async with EXPRESSION as TARGET:
    SUITE

manager = (EXPRESSION)
aenter = type(manager).__aenter__
aexit = type(manager).__aexit__
value = await aenter(manager)
hit_except = False

try:
    TARGET = value
    SUITE
except:
    hit_except = True
    if not await aexit(manager, *sys.exc_info()):
        raise
finally:
    if not hit_except:
        await aexit(manager, None, None, None)