8. 復合語句?

8.1. if 語句?

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

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

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

8.2. while 語句?

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

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

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

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

8.3. for 語句?

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

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.

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

for 循環(huán)會對目標列表中的變量進行賦值。 這將覆蓋之前對這些變量的所有賦值，包括在 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

目標列表中的名稱在循環(huán)結束時不會被刪除，但如果序列為空，則它們根本不會被循環(huán)所賦值。 提示：內(nèi)置函數(shù) range() 會返回一個可迭代的整數(shù)序列，適用于模擬 Pascal 中的 for i := a to b do 這種效果；例如 list(range(3)) 會返回列表 [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 子句與異常相匹配，則會在周邊代碼和發(fā)起調(diào)用棧上繼續(xù)搜索異常處理器。 1

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

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

當使用 as 將目標賦值為一個異常時，它將在 except 子句結束時被清除。 這就相當于

except E as N:
    foo

被轉寫為

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

這意味著異常必須賦值給一個不同的名稱才能在 except 子句之后引用它。 異常會被清除是因為在附加了回溯信息的情況下，它們會形成堆棧幀的循環(huán)引用，使得所有局部變量保持存活直到發(fā)生下一次垃圾回收。

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

>>> 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 子句體時沒有引發(fā)異常，并且沒有執(zhí)行 return, continue 或 break 語句，可選的 else 子句將被執(zhí)行。 else 語句中的異常不會由之前的 except 子句處理。

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

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

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

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

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

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

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

8.5. with 語句?

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

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

帶有一個“項目”的 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 語句中包含一個目標，來自 __enter__() 的返回值將被賦值給它。

   備注

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

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

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

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

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

以下代碼:

with EXPRESSION as TARGET:
    SUITE

在語義上等價于:

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)

如果有多個項目，則會視作存在多個 with 語句嵌套來處理多個上下文管理器:

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

在語義上等價于:

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

也可以用圓括號包圍的多行形式的多項目上下文管理器。例如:

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

8.6. match 語句?

匹配語句用于進行模式匹配。語法如下：

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

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

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

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

關鍵字 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ù)定義就是對用戶自定義函數(shù)的定義（參見 標準類型層級結構 一節(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ù)名稱綁定到一個函數(shù)對象（函數(shù)可執(zhí)行代碼的包裝器）。 這個函數(shù)對象包含對當前全局命名空間的引用，作為函數(shù)被調(diào)用時所使用的全局命名空間。

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

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

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

大致等價于

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

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

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

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

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

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

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

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

8.8. 類定義?

類定義就是對類對象的定義 (參見 標準類型層級結構 一節(jié)):

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

類定義是一條可執(zhí)行語句。 其中繼承列表通常給出基類的列表 (進階用法請參見 元類)，列表中的每一項都應當被求值為一個允許子類的類對象。 沒有繼承列表的類默認繼承自基類 object；因此，:

class Foo:
    pass

等價于

class Foo(object):
    pass

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

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

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

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

@f1(arg)
@f2
class Foo: pass

大致等價于

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

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

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

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)