8. 复合语句 ¶

复合语句包含 (分组) 其它语句；它们以某种方式影响 (或控制) 其它语句的执行。一般而言，复合语句跨多行，尽管简单化身可以将整个复合语句包含在一行中。

if , while and for statements implement traditional control flow constructs. try specifies exception handlers and/or cleanup code for a group of statements, while the with statement allows the execution of initialization and finalization code around a block of code. Function and class definitions are also syntactically compound statements.

A compound statement consists of one or more ‘clauses.’ A clause consists of a header and a ‘suite.’ The clause headers of a particular compound statement are all at the same indentation level. Each clause header begins with a uniquely identifying keyword and ends with a colon. A suite is a group of statements controlled by a clause. A suite can be one or more semicolon-separated simple statements on the same line as the header, following the header’s colon, or it can be one or more indented statements on subsequent lines. Only the latter form of a suite can contain nested compound statements; the following is illegal, mostly because it wouldn’t be clear to which if clause a following else clause would belong:

if test1: if test2: print(x)
					

Also note that the semicolon binds tighter than the colon in this context, so that in the following example, either all or none of the print() calls are executed:

if x < y < z: print(x); print(y); print(z)
					

汇总：

compound_stmt ::=  if_stmt
                   | while_stmt
                   | for_stmt
                   | try_stmt
                   | with_stmt
                   | match_stmt
                   | funcdef
                   | classdef
                   | async_with_stmt
                   | async_for_stmt
                   | async_funcdef
suite         ::=  stmt_list NEWLINE | NEWLINE INDENT statement+ DEDENT
statement     ::=  stmt_list NEWLINE | compound_stmt
stmt_list     ::=  simple_stmt (";" simple_stmt)* [";"]
					

Note that statements always end in a NEWLINE possibly followed by a DEDENT . Also note that optional continuation clauses always begin with a keyword that cannot start a statement, thus there are no ambiguities (the ‘dangling else ’ problem is solved in Python by requiring nested if statements to be indented).

The formatting of the grammar rules in the following sections places each clause on a separate line for clarity.

8.1. if 语句 ¶

if 语句用于条件执行：

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

It selects exactly one of the suites by evaluating the expressions one by one until one is found to be true (see section 布尔运算 for the definition of true and false); then that suite is executed (and no other part of the if statement is executed or evaluated). If all expressions are false, the suite of the else clause, if present, is executed.

8.2. while 语句 ¶

while 语句用于重复执行只要表达式为 True：

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

这将反复测试表达式，若为 True，执行第一套件；若表达式为 False (可能是首次测试)，执行套件 else 子句，若它存在，执行并循环终止。

A break 语句在第一套件中执行将终止循环而不执行 else 子句套件。 continue 语句在第一套件中执行将跳过套件的其余部分并回到测试表达式。

8.3. for 语句 ¶

for statement is used to iterate over the elements of a sequence (such as a string, tuple or list) or other iterable object:

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

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.

A break 语句在第一套件中执行将终止循环而不执行 else 子句套件。 continue statement executed in the first suite skips the rest of the suite and continues with the next item, or with the else clause if there is no next item.

The for-loop makes assignments to the variables in the target list. This overwrites all previous assignments to those variables including those made in the suite of the for-loop:

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
					

Names in the target list are not deleted when the loop is finished, but if the sequence is empty, they will not have been assigned to at all by the loop. Hint: the built-in function range() returns an iterator of integers suitable to emulate the effect of Pascal’s for i := a to b do ; e.g., list(range(3)) returns the list [0, 1, 2] .

3.11 版改变： Starred elements are now allowed in the expression list.

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
					

可以找到有关异常的额外信息在章节 异常 , and information on using the raise statement to generate exceptions may be found in section raise 语句 .

8.4.1. except clause ¶

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 clause matches the exception, the search for an exception handler continues in the surrounding code and on the invocation stack. 1

If the evaluation of an expression in the header of an except clause raises an exception, the original search for a handler is canceled and a search starts for the new exception in the surrounding code and on the call stack (it is treated as if the entire try statement raised the exception).

When a matching except clause is found, the exception is assigned to the target specified after the as keyword in that except clause, if present, and the except clause’s suite is executed. All except clauses must have an executable block. When the end of this block is reached, execution continues normally after the entire try statement. (This means that if two nested handlers exist for the same exception, and the exception occurs in the try clause of the inner handler, the outer handler will not handle the exception.)

When an exception has been assigned using as target , it is cleared at the end of the except clause. This is as if

except E as N:
    foo
					

was translated to

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

This means the exception must be assigned to a different name to be able to refer to it after the except clause. Exceptions are cleared because with the traceback attached to them, they form a reference cycle with the stack frame, keeping all locals in that frame alive until the next garbage collection occurs.

Before an except clause’s suite is executed, details about the exception are stored in the sys module and can be accessed via sys.exc_info() . sys.exc_info() returns a 3-tuple consisting of the exception class, the exception instance and a traceback object (see section 标准类型层次结构 ) identifying the point in the program where the exception occurred. The details about the exception accessed via sys.exc_info() are restored to their previous values when leaving an exception handler:

>>> 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)
					

8.4.2. except* clause ¶

except* clause(s) are used for handling ExceptionGroup s. 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 :keyword:`!except*`
clause are re-raised at the end, combined into an exception group along with
all exceptions that were raised from within :keyword:`!except*` clauses.
An :keyword:`!except*` clause must have a matching type,
and this type cannot be a subclass of :exc:`BaseExceptionGroup`.
It is not possible to mix :keyword:`except` and :keyword:`!except*`
in the same :keyword:`try`.
:keyword:`break`, :keyword:`continue` and :keyword:`return`
cannot appear in an :keyword:`!except*` clause.
					

8.4.3. else clause ¶

可选 else 子句会被执行，若控制流离开 try suite, no exception was raised, and no return , continue ，或 break statement was executed. Exceptions in the else clause are not handled by the preceding except clauses.

8.4.4. finally clause ¶

若 finally is present, it specifies a ‘cleanup’ handler. The try clause is executed, including any except and else clauses. If an exception occurs in any of the clauses and is not handled, the exception is temporarily saved. The finally clause is executed. If there is a saved exception it is re-raised at the end of the finally clause. If the finally clause raises another exception, the saved exception is set as the context of the new exception. If the finally 子句执行 return , break or continue statement, the saved exception is discarded:

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

The exception information is not available to the program during execution of the finally 子句。

当 return , break or continue statement is executed in the try suite of a try … finally statement, the finally clause is also executed ‘on the way out.’

The return value of a function is determined by the last return statement executed. Since the finally clause always executes, a return statement executed in the finally clause will always be the last one executed:

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

3.8 版改变： Prior to Python 3.8, a continue statement was illegal in the finally clause due to a problem with the implementation.

8.5. with 语句 ¶

with statement is used to wrap the execution of a block with methods defined by a context manager (see section with 语句上下文管理器 )。这允许常见 try … except … finally usage patterns to be encapsulated for convenient reuse.

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

The execution of the with statement with one “item” proceeds as follows:

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

2. The context manager’s __enter__() is loaded for later use.

3. The context manager’s __exit__() is loaded for later use.

4. The context manager’s __enter__() method is invoked.

5. If a target was included in the with statement, the return value from __enter__() is assigned to it.

   注意

   with statement guarantees that if the __enter__() method returns without an error, then __exit__() will always be called. Thus, if an error occurs during the assignment to the target list, it will be treated the same as an error occurring within the suite would be. See step 6 below.

6. The suite is executed.

7. The context manager’s __exit__() method is invoked. If an exception caused the suite to be exited, its type, value, and traceback are passed as arguments to __exit__() . Otherwise, three None arguments are supplied.

   If the suite was exited due to an exception, and the return value from the __exit__() method was false, the exception is reraised. If the return value was true, the exception is suppressed, and execution continues with the statement following the with 语句。

   If the suite was exited for any reason other than an exception, the return value from __exit__() is ignored, and execution proceeds at the normal location for the kind of exit that was taken.

以下代码：

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 more than one item, the context managers are processed as if multiple with statements were nested:

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

语义上相当于：

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

You can also write multi-item context managers in multiple lines if the items are surrounded by parentheses. For example:

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

3.1 版改变： 支持多上下文表达式。

3.10 版改变： Support for using grouping parentheses to break the statement in multiple lines.

另请参阅

PEP 343 - with 语句

规范、背景及范例为 Python with 语句。

8.6. match 语句 ¶

3.10 版新增。

The match statement is used for pattern matching. Syntax:

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
					

注意

This section uses single quotes to denote soft keywords .

Pattern matching takes a pattern as input (following case ) and a subject value (following match ). The pattern (which may contain subpatterns) is matched against the subject value. The outcomes are:

• A match success or failure (also termed a pattern success or failure).

• Possible binding of matched values to a name. The prerequisites for this are further discussed below.

match and case keywords are soft keywords .

另请参阅

• PEP 634 – Structural Pattern Matching: Specification

• PEP 636 – Structural Pattern Matching: Tutorial

8.6.1. 概述 ¶

Here’s an overview of the logical flow of a match statement:

1. The subject expression subject_expr is evaluated and a resulting subject value obtained. If the subject expression contains a comma, a tuple is constructed using the standard rules .

2. Each pattern in a case_block is attempted to match with the subject value. The specific rules for success or failure are described below. The match attempt can also bind some or all of the standalone names within the pattern. The precise pattern binding rules vary per pattern type and are specified below. Name bindings made during a successful pattern match outlive the executed block and can be used after the match statement .

   注意

   During failed pattern matches, some subpatterns may succeed. Do not rely on bindings being made for a failed match. Conversely, do not rely on variables remaining unchanged after a failed match. The exact behavior is dependent on implementation and may vary. This is an intentional decision made to allow different implementations to add optimizations.

3. If the pattern succeeds, the corresponding guard (if present) is evaluated. In this case all name bindings are guaranteed to have happened.

   • If the guard evaluates as true or is missing, the block inside case_block is executed.

   • Otherwise, the next case_block is attempted as described above.

   • If there are no further case blocks, the match statement is completed.

注意

Users should generally never rely on a pattern being evaluated. Depending on implementation, the interpreter may cache values or use other optimizations which skip repeated evaluations.

A sample match statement:

>>> 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
					

在此情况下， if flag is a guard. Read more about that in the next section.

8.6.2. Guards ¶

guard ::=  "if" named_expression
					

guard (which is part of the case ) must succeed for code inside the case block to execute. It takes the form: if followed by an expression.

The logical flow of a case block with a guard follows:

1. Check that the pattern in the case block succeeded. If the pattern failed, the guard is not evaluated and the next case block is checked.

2. If the pattern succeeded, evaluate the guard .

   • 若 guard condition evaluates as true, the case block is selected.

   • 若 guard condition evaluates as false, the case block is not selected.

   • 若 guard raises an exception during evaluation, the exception bubbles up.

Guards are allowed to have side effects as they are expressions. Guard evaluation must proceed from the first to the last case block, one at a time, skipping case blocks whose pattern(s) don’t all succeed. (I.e., guard evaluation must happen in order.) Guard evaluation must stop once a case block is selected.

8.6.3. Irrefutable Case Blocks ¶

An irrefutable case block is a match-all case block. A match statement may have at most one irrefutable case block, and it must be last.

A case block is considered irrefutable if it has no guard and its pattern is irrefutable. A pattern is considered irrefutable if we can prove from its syntax alone that it will always succeed. Only the following patterns are irrefutable:

• AS Patterns whose left-hand side is irrefutable

• OR Patterns containing at least one irrefutable pattern

• Capture Patterns

• Wildcard Patterns

• parenthesized irrefutable patterns

8.6.4. Patterns ¶

注意

This section uses grammar notations beyond standard EBNF:

• 表示法 SEP.RULE+ is shorthand for RULE (SEP RULE)*

• 表示法 !RULE is shorthand for a negative lookahead assertion

The top-level syntax for patterns is:

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
					

The descriptions below will include a description “in simple terms” of what a pattern does for illustration purposes (credits to Raymond Hettinger for a document that inspired most of the descriptions). Note that these descriptions are purely for illustration purposes and may not reflect the underlying implementation. Furthermore, they do not cover all valid forms.

8.6.4.1. OR Patterns ¶

An OR pattern is two or more patterns separated by vertical bars | . Syntax:

or_pattern ::=  "|".closed_pattern+
					

Only the final subpattern may be irrefutable , and each subpattern must bind the same set of names to avoid ambiguity.

An OR pattern matches each of its subpatterns in turn to the subject value, until one succeeds. The OR pattern is then considered successful. Otherwise, if none of the subpatterns succeed, the OR pattern fails.

In simple terms, P1 | P2 | ... will try to match P1 , if it fails it will try to match P2 , succeeding immediately if any succeeds, failing otherwise.

8.6.4.2. AS Patterns ¶

An AS pattern matches an OR pattern on the left of the as keyword against a subject. Syntax:

as_pattern ::=  or_pattern "as" capture_pattern
					

If the OR pattern fails, the AS pattern fails. Otherwise, the AS pattern binds the subject to the name on the right of the as keyword and succeeds. capture_pattern cannot be a a _ .

In simple terms P as NAME will match with P , and on success it will set NAME = <subject> .

8.6.4.3. Literal Patterns ¶

A literal pattern corresponds to most literals in Python. Syntax:

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

The rule strings and the token NUMBER are defined in the standard Python grammar . Triple-quoted strings are supported. Raw strings and byte strings are supported. 格式化字符串文字 不支持。

The forms signed_number '+' NUMBER and signed_number '-' NUMBER are for expressing 复数 ; they require a real number on the left and an imaginary number on the right. E.g. 3 + 4j .

In simple terms, LITERAL will succeed only if <subject> == LITERAL . For the singletons None , True and False ， is operator is used.

8.6.4.4. Capture Patterns ¶

A capture pattern binds the subject value to a name. Syntax:

capture_pattern ::=  !'_' NAME
					

A single underscore _ is not a capture pattern (this is what !'_' expresses). It is instead treated as a wildcard_pattern .

In a given pattern, a given name can only be bound once. E.g. case x, x: ... is invalid while case [x] | x: ... is allowed.

Capture patterns always succeed. The binding follows scoping rules established by the assignment expression operator in PEP 572 ; the name becomes a local variable in the closest containing function scope unless there’s an applicable global or nonlocal 语句。

In simple terms NAME will always succeed and it will set NAME = <subject> .

8.6.4.5. Wildcard Patterns ¶

A wildcard pattern always succeeds (matches anything) and binds no name. Syntax:

wildcard_pattern ::=  '_'
					

_ 是 soft keyword within any pattern, but only within patterns. It is an identifier, as usual, even within match subject expressions, guard s, and case blocks.

In simple terms, _ will always succeed.

8.6.4.6. Value Patterns ¶

A value pattern represents a named value in Python. Syntax:

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

The dotted name in the pattern is looked up using standard Python name resolution rules . The pattern succeeds if the value found compares equal to the subject value (using the == equality operator).

In simple terms NAME1.NAME2 will succeed only if <subject> == NAME1.NAME2

注意

If the same value occurs multiple times in the same match statement, the interpreter may cache the first value found and reuse it rather than repeat the same lookup. This cache is strictly tied to a given execution of a given match statement.

8.6.4.7. Group Patterns ¶

A group pattern allows users to add parentheses around patterns to emphasize the intended grouping. Otherwise, it has no additional syntax. Syntax:

group_pattern ::=  "(" pattern ")"
					

In simple terms (P) has the same effect as P .

8.6.4.8. Sequence Patterns ¶

A sequence pattern contains several subpatterns to be matched against sequence elements. The syntax is similar to the unpacking of a list or tuple.

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)
					

There is no difference if parentheses or square brackets are used for sequence patterns (i.e. (...) vs [...] ).

注意

A single pattern enclosed in parentheses without a trailing comma (e.g. (3 | 4) ) is a group pattern . While a single pattern enclosed in square brackets (e.g. [3 | 4] ) is still a sequence pattern.

At most one star subpattern may be in a sequence pattern. The star subpattern may occur in any position. If no star subpattern is present, the sequence pattern is a fixed-length sequence pattern; otherwise it is a variable-length sequence pattern.

The following is the logical flow for matching a sequence pattern against a subject value:

1. If the subject value is not a sequence 2 , the sequence pattern fails.

2. If the subject value is an instance of str , bytes or bytearray the sequence pattern fails.

3. The subsequent steps depend on whether the sequence pattern is fixed or variable-length.

   If the sequence pattern is fixed-length:

   1. If the length of the subject sequence is not equal to the number of subpatterns, the sequence pattern fails

   2. Subpatterns in the sequence pattern are matched to their corresponding items in the subject sequence from left to right. Matching stops as soon as a subpattern fails. If all subpatterns succeed in matching their corresponding item, the sequence pattern succeeds.

   Otherwise, if the sequence pattern is variable-length:

   1. If the length of the subject sequence is less than the number of non-star subpatterns, the sequence pattern fails.

   2. The leading non-star subpatterns are matched to their corresponding items as for fixed-length sequences.

   3. If the previous step succeeds, the star subpattern matches a list formed of the remaining subject items, excluding the remaining items corresponding to non-star subpatterns following the star subpattern.

   4. Remaining non-star subpatterns are matched to their corresponding subject items, as for a fixed-length sequence.

   注意

   The length of the subject sequence is obtained via len() (i.e. via the __len__() protocol). This length may be cached by the interpreter in a similar manner as value patterns .

In simple terms [P1, P2, P3, … , P<N>] matches only if all the following happens:

• check <subject> is a sequence

• len(subject) == <N>

• P1 匹配 <subject>[0] (note that this match can also bind names)

• P2 匹配 <subject>[1] (note that this match can also bind names)

• … and so on for the corresponding pattern/element.

8.6.4.9. Mapping Patterns ¶

A mapping pattern contains one or more key-value patterns. The syntax is similar to the construction of a dictionary. Syntax:

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
					

At most one double star pattern may be in a mapping pattern. The double star pattern must be the last subpattern in the mapping pattern.

Duplicate keys in mapping patterns are disallowed. Duplicate literal keys will raise a SyntaxError . Two keys that otherwise have the same value will raise a ValueError at runtime.

The following is the logical flow for matching a mapping pattern against a subject value:

1. If the subject value is not a mapping 3 ,the mapping pattern fails.

2. If every key given in the mapping pattern is present in the subject mapping, and the pattern for each key matches the corresponding item of the subject mapping, the mapping pattern succeeds.

3. If duplicate keys are detected in the mapping pattern, the pattern is considered invalid. A SyntaxError is raised for duplicate literal values; or a ValueError for named keys of the same value.

注意

Key-value pairs are matched using the two-argument form of the mapping subject’s get() method. Matched key-value pairs must already be present in the mapping, and not created on-the-fly via __missing__() or __getitem__() .

In simple terms {KEY1: P1, KEY2: P2, ... } matches only if all the following happens:

• check <subject> is a mapping

• KEY1 in <subject>

• P1 匹配 <subject>[KEY1]

• … and so on for the corresponding KEY/pattern pair.

8.6.4.10. Class Patterns ¶

A class pattern represents a class and its positional and keyword arguments (if any). Syntax:

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
					

The same keyword should not be repeated in class patterns.

The following is the logical flow for matching a class pattern against a subject value:

1. 若 name_or_attr is not an instance of the builtin type , raise TypeError .

2. If the subject value is not an instance of name_or_attr (tested via isinstance() ), the class pattern fails.

3. If no pattern arguments are present, the pattern succeeds. Otherwise, the subsequent steps depend on whether keyword or positional argument patterns are present.

   For a number of built-in types (specified below), a single positional subpattern is accepted which will match the entire subject; for these types keyword patterns also work as for other types.

   If only keyword patterns are present, they are processed as follows, one by one:

   I. The keyword is looked up as an attribute on the subject.

   • If this raises an exception other than AttributeError , the exception bubbles up.

   • If this raises AttributeError , the class pattern has failed.

   • Else, the subpattern associated with the keyword pattern is matched against the subject’s attribute value. If this fails, the class pattern fails; if this succeeds, the match proceeds to the next keyword.

   II. If all keyword patterns succeed, the class pattern succeeds.

   If any positional patterns are present, they are converted to keyword patterns using the __match_args__ attribute on the class name_or_attr before matching:

   I. The equivalent of getattr(cls, "__match_args__", ()) 被调用。

   • If this raises an exception, the exception bubbles up.

   • If the returned value is not a tuple, the conversion fails and TypeError 被引发。

   • If there are more positional patterns than len(cls.__match_args__) , TypeError 被引发。

   • Otherwise, positional pattern i is converted to a keyword pattern using __match_args__[i] as the keyword. __match_args__[i] must be a string; if not TypeError 被引发。

   • If there are duplicate keywords, TypeError 被引发。

   另请参阅

   定制类模式匹配中的位置自变量

   II. Once all positional patterns have been converted to keyword patterns,

   the match proceeds as if there were only keyword patterns.

   For the following built-in types the handling of positional subpatterns is different:

   • bool

   • bytearray

   • bytes

   • dict

   • float

   • frozenset

   • int

   • list

   • set

   • str

   • tuple

   These classes accept a single positional argument, and the pattern there is matched against the whole object rather than an attribute. For example int(0|1) matches the value 0 , but not the value 0.0 .

In simple terms CLS(P1, attr=P2) matches only if the following happens:

• isinstance(<subject>, CLS)

• convert P1 to a keyword pattern using CLS.__match_args__

• For each keyword argument attr=P2 :

  • hasattr(<subject>, "attr")

  • P2 匹配 <subject>.attr

• … and so on for the corresponding keyword argument/pattern pair.

另请参阅

• PEP 634 – Structural Pattern Matching: Specification

• PEP 636 – Structural Pattern Matching: Tutorial

8.7. 函数定义 ¶

函数定义定义用户定义的函数对象 (见章节 标准类型层次结构 ):

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
					

函数定义是可执行语句。它的执行是把当前本地名称空间中的函数名称绑定到函数对象 (围绕函数可执行代码的包裹器)。此函数对象包含当前全局名称空间 (作为要使用的全局名称空间) 的引用，当函数被调用时。

函数定义不执行函数本体；这才获得执行，当函数被调用时。 4

函数定义可以被包裹通过一个或多个 装饰器 表达式。评估装饰器表达式当定义函数时，在包含函数定义的作用域内。结果必须是可调用，它以函数对象作为唯一自变量被援引。返回值被绑定到函数名称，而不是函数对象。多个装饰器按嵌套方式应用。例如，以下代码

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

大致相当于

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

除了原始函数不被临时绑定到名称 func .

3.9 版改变： 可以装饰函数采用任何有效 assignment_expression 。先前，语法的限定要多得多；见 PEP 614 了解细节。

当一个或多个 参数 拥有形式 参数 = 表达式 ，函数被称为拥有 "默认参数值"。对于具有默认值的参数，相应 argument 可以从调用省略，在这种情况下，参数的默认值被代入。若参数拥有默认值，所有之后参数直到 * 还必须拥有默认值 — 这是语法未表达的句法限定。

会从左到右评估默认参数值，当执行函数定义时。 This means that the expression is evaluated once, when the function is defined, and that the same “pre-computed” value is used for each call. This is especially important to understand when a default parameter value is a mutable object, such as a list or a dictionary: if the function modifies the object (e.g. by appending an item to a list), the default parameter value is in effect modified. This is generally not what was intended. A way around this is to use None 作为默认值，并在函数本体中明确测试它，如：

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

函数调用语义的更详细描述在章节 调用 。函数调用始终将值赋值给参数列表中提及的所有参数，从位置自变量、从关键词自变量或从默认值。若形式 *identifier 存在，它被初始化成接收任何多余位置参数的元组，默认为空元组。若形式 **identifier 存在，它被初始化成接收任何多余关键词自变量的新有序映射，默认为相同类型的新的空映射。参数后于 * 或 *identifier 为仅关键词参数且只可以传递关键词自变量。参数前于 / 为仅位置参数且只可以传递位置自变量。

3.8 版改变： / 函数参数句法可以用于指示仅位置参数。见 PEP 570 了解细节。

参数可以拥有 annotation 形式 : expression 紧跟参数名。任何参数都可以拥有注释，即使是这些形式 *identifier or **identifier 。函数可以拥有 return 注解形式 -> expression 在参数列表后。这些注解可以是任何有效 Python 表达式。存在的注解不会改变函数的语义。注解值可用作字典键值通过参数名称在 __annotations__ 属性对于函数对象。若 annotations 导入自 __future__ 的使用，注解在运行时被预留作为字符串启用延期评估。否则，当执行函数定义时会评估它们。在这种情况下，注解的评估可能异于它们在源代码中的出现次序。

创建立即用于表达式的匿名函数 (不绑定到名称的函数) 也是可能的。这使用 Lambda 表达式，描述在章节 Lambda 。注意，Lambda 表达式仅仅是简化函数定义的简写；函数的定义在 def 语句可以传递或赋值另一名称，就像通过 Lambda 表达式定义的函数。 def 形式实际上更强大，由于它允许执行多条语句和注解。

程序员注意： 函数是首类对象。 def 语句在可以返回或传递局部函数的函数定义中执行。在嵌套函数中使用的自由变量，可以访问包含 def 的函数的局部变量。见章节 命名和绑定 了解细节。

另请参阅

PEP 3107 - 函数注解

函数注解的原始规范。

PEP 484 - 类型提示

标准注解含义的定义：类型提示。

PEP 526 - 变量注解句法

类型提示变量声明的能力，包括类变量和实例变量

PEP 563 - 注解延期评估

支持在注解中向前引用，通过在运行时以字符串形式保留注解而不是渴望评估。

8.8. 类定义 ¶

类定义定义类对象 (见章节 标准类型层次结构 ):

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

A class definition is an executable statement. The inheritance list usually gives a list of base classes (see 元类 for more advanced uses), so each item in the list should evaluate to a class object which allows subclassing. Classes without an inheritance list inherit, by default, from the base class object ; hence,

class Foo:
    pass
					

相当于

class Foo(object):
    pass
					

The class’s suite is then executed in a new execution frame (see 命名和绑定 ), using a newly created local namespace and the original global namespace. (Usually, the suite contains mostly function definitions.) When the class’s suite finishes execution, its execution frame is discarded but its local namespace is saved. 5 A class object is then created using the inheritance list for the base classes and the saved local namespace for the attribute dictionary. The class name is bound to this class object in the original local namespace.

The order in which attributes are defined in the class body is preserved in the new class’s __dict__ . Note that this is reliable only right after the class is created and only for classes that were defined using the definition syntax.

Class creation can be customized heavily using metaclasses .

Classes can also be decorated: just like when decorating functions,

@f1(arg)
@f2
class Foo: pass
					

大致相当于

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

The evaluation rules for the decorator expressions are the same as for function decorators. The result is then bound to the class name.

3.9 版改变： Classes may be decorated with any valid assignment_expression 。先前，语法的限定要多得多；见 PEP 614 了解细节。

程序员注意： Variables defined in the class definition are class attributes; they are shared by instances. Instance attributes can be set in a method with self.name = value . Both class and instance attributes are accessible through the notation “ self.name ”, and an instance attribute hides a class attribute with the same name when accessed in this way. Class attributes can be used as defaults for instance attributes, but using mutable values there can lead to unexpected results. Descriptors can be used to create instance variables with different implementation details.

另请参阅

PEP 3115 - Python 3000 的元类

The proposal that changed the declaration of metaclasses to the current syntax, and the semantics for how classes with metaclasses are constructed.

PEP 3129 - 类装饰器

The proposal that added class decorators. Function and method decorators were introduced in PEP 318 .

8.9. 协程 ¶

3.5 版新增。

8.9.1. 协程函数定义 ¶

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

可以在许多点挂起和再继续 Python 协程的执行 (见 协程 ). await 表达式， async for and async with can only be used in the body of a coroutine function.

函数定义采用 async def 句法始终是协程函数，即使它们不包含 await or async 关键词。

它是 SyntaxError 要使用 yield from 表达式在协程函数本体内。

协程函数范例：

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

3.7 版改变： await and async are now keywords; previously they were only treated as such inside the body of a coroutine function.

8.9.2. async for 语句 ¶

async_for_stmt ::=  "async" for_stmt
						

An 异步可迭代 提供 __aiter__ 方法直接返回 异步迭代器 ，可以调用异步代码在其 __anext__ 方法。

async for 语句允许方便迭代异步可迭代。

以下代码：

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
					

另请参阅 __aiter__() and __anext__() 了解细节。

它是 SyntaxError 要使用 async for 语句在协程函数本体外。

8.9.3. async with 语句 ¶

async_with_stmt ::=  "async" with_stmt
					

An 异步上下文管理器 是 上下文管理器 能挂起执行在其 enter and exit 方法。

以下代码：

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)
					

另请参阅 __aenter__() and __aexit__() 了解细节。

它是 SyntaxError 要使用 async with 语句在协程函数本体外。

另请参阅

PEP 492 具有 async 和 await 句法的协程

使协程成为 Python 中的适当独立概念，并添加了支持句法的提案。

脚注

1

The exception is propagated to the invocation stack unless there is a finally clause which happens to raise another exception. That new exception causes the old one to be lost.

2

In pattern matching, a sequence is defined as one of the following:

• a class that inherits from collections.abc.Sequence

• a Python class that has been registered as collections.abc.Sequence

• a builtin class that has its (CPython) Py_TPFLAGS_SEQUENCE bit set

• a class that inherits from any of the above

以下标准库类是序列：

• array.array

• collections.deque

• list

• memoryview

• range

• tuple

注意

Subject values of type str , bytes ，和 bytearray do not match sequence patterns.

3

In pattern matching, a mapping is defined as one of the following:

• a class that inherits from collections.abc.Mapping

• a Python class that has been registered as collections.abc.Mapping

• a builtin class that has its (CPython) Py_TPFLAGS_MAPPING bit set

• a class that inherits from any of the above

The standard library classes dict and types.MappingProxyType are mappings.

4

A string literal appearing as the first statement in the function body is transformed into the function’s __doc__ attribute and therefore the function’s docstring .

5

A string literal appearing as the first statement in the class body is transformed into the namespace’s __doc__ item and therefore the class’s docstring .

内容表

• 8. 复合语句
  • 8.1. if 语句
  • 8.2. while 语句
  • 8.3. for 语句
  • 8.4. try 语句
    • 8.4.1. except clause
    • 8.4.2. except* clause
    • 8.4.3. else clause
    • 8.4.4. finally clause
  • 8.5. with 语句
  • 8.6. match 语句
    • 8.6.1. 概述
    • 8.6.2. 守卫
    • 8.6.3. Irrefutable Case Blocks
    • 8.6.4. 模式
      • 8.6.4.1. OR Patterns
      • 8.6.4.2. AS Patterns
      • 8.6.4.3. Literal Patterns
      • 8.6.4.4. Capture Patterns
      • 8.6.4.5. Wildcard Patterns
      • 8.6.4.6. Value Patterns
      • 8.6.4.7. Group Patterns
      • 8.6.4.8. Sequence Patterns
      • 8.6.4.9. Mapping Patterns
      • 8.6.4.10. Class Patterns
  • 8.7. 函数定义
  • 8.8. 类定义
  • 8.9. 协程
    • 8.9.1. 协程函数定义
    • 8.9.2. async for 语句
    • 8.9.3. async with 语句

上一话题

7. 简单语句

下一话题

9. 顶层组件

本页

• 报告 Bug
• 展示源