内容表

8. 复合语句

上一话题

下一话题

8. 复合语句 ¶

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

The 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. The `if` 语句 ¶

The 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. The `while` 语句 ¶

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

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

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

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

8.3. The `for` 语句 ¶

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

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.

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 type range() represents immutable arithmetic sequences of integers. For instance, iterating range(3) successively yields 0, 1, and then 2.

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

8.4. The `try` 语句 ¶

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

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 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, the exception is stored in the sys module, where it can be accessed from within the body of the except clause by calling sys.exception() . When leaving an exception handler, the exception stored in the sys module is reset to its previous value:

>>> print(sys.exception())
None
>>> try:
...     raise TypeError
... except:
...     print(repr(sys.exception()))
...     try:
...          raise ValueError
...     except:
...         print(repr(sys.exception()))
...     print(repr(sys.exception()))
...
TypeError()
ValueError()
TypeError()
>>> print(sys.exception())
None

8.4.2. `except*` clause ¶

The 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 at most 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, along with all exceptions that were raised from within the except* clauses. If this list contains more than one exception to reraise, they are combined into an exception group.

If the raised exception is not an exception group and its type matches one of the except* clauses, it is caught and wrapped by an exception group with an empty message string.

>>> try:
...     raise BlockingIOError
... except* BlockingIOError as e:
...     print(repr(e))
...
ExceptionGroup('', (BlockingIOError()))

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

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. The `with` 语句 ¶

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

The context expression (the expression given in the with_item ) is evaluated to obtain a context manager.
The context manager’s __enter__() is loaded for later use.
The context manager’s __exit__() is loaded for later use.
The context manager’s __enter__() method is invoked.
If a target was included in the with statement, the return value from __enter__() is assigned to it.

注意

The 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 7 below.
The suite is executed.
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. The `match` 语句 ¶

Added in version 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.

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

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

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

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

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. f-strings 不支持。

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 ，和 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:

If the subject value is not a sequence [ 2 ] , the sequence pattern fails.
If the subject value is an instance of str , bytes or bytearray the sequence pattern fails.
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:

If the subject value is not a mapping [ 3 ] ,the mapping pattern fails.
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.
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:

若 name_or_attr is not an instance of the builtin type , raise TypeError .
If the subject value is not an instance of name_or_attr (tested via isinstance() ), the class pattern fails.
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:

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 [type_params] "(" [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 了解细节。

列表化的 type parameters may be given in square brackets between the function’s name and the opening parenthesis for its parameter list. This indicates to static type checkers that the function is generic. At runtime, the type parameters can be retrieved from the function’s __type_params__ 属性。见 Generic functions for more.

Changed in version 3.12: Type parameter lists are new in Python 3.12.

当一个或多个参数拥有形式参数 = 表达式 ，函数被称为拥有 "默认参数值"。对于具有默认值的参数，相应 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 版改变： The / 函数参数句法可以用于指示仅位置参数。见 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 - 变量注解句法: Ability to type hint variable declarations, including class variables and instance variables.
PEP 563 - 注解延期评估: 支持在注解中向前引用，通过在运行时以字符串形式保留注解而不是渴望评估。
PEP 318 - Decorators for Functions and Methods: Function and method decorators were introduced. Class decorators were introduced in PEP 3129 .

8.8. 类定义 ¶

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

classdef    ::=  [decorators] "class" classname [type_params] [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 了解细节。

列表化的 type parameters may be given in square brackets immediately after the class’s name. This indicates to static type checkers that the class is generic. At runtime, the type parameters can be retrieved from the class’s __type_params__ 属性。见 Generic classes for more.

Changed in version 3.12: Type parameter lists are new in Python 3.12.

程序员注意： 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. 协程 ¶

Added in version 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. The `async for` 语句 ¶

async_for_stmt ::=  "async" for_stmt

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

The 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. The `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 中的适当独立概念，并添加了支持句法的提案。

8.10. Type parameter lists ¶

3.12 版添加。

type_params  ::=  "[" type_param ("," type_param)* "]"
type_param   ::=  typevar | typevartuple | paramspec
typevar      ::=  identifier (":" expression)?
typevartuple ::=  "*" identifier
paramspec    ::=  "**" identifier

函数 (including 协程 ), 类 and type aliases may contain a type parameter list:

def max[T](args: list[T]) -> T:
    ...
async def amax[T](args: list[T]) -> T:
    ...
class Bag[T]:
    def __iter__(self) -> Iterator[T]:
        ...
    def add(self, arg: T) -> None:
        ...
type ListOrSet[T] = list[T] | set[T]

Semantically, this indicates that the function, class, or type alias is generic over a type variable. This information is primarily used by static type checkers, and at runtime, generic objects behave much like their non-generic counterparts.

Type parameters are declared in square brackets ( [] ) immediately after the name of the function, class, or type alias. The type parameters are accessible within the scope of the generic object, but not elsewhere. Thus, after a declaration def func[T](): pass , the name T is not available in the module scope. Below, the semantics of generic objects are described with more precision. The scope of type parameters is modeled with a special function (technically, an annotation scope ) that wraps the creation of the generic object.

Generic functions, classes, and type aliases have a __type_params__ attribute listing their type parameters.

Type parameters come in three kinds:

typing.TypeVar , introduced by a plain name (e.g., T ). Semantically, this represents a single type to a type checker.
typing.TypeVarTuple , introduced by a name prefixed with a single asterisk (e.g., *Ts ). Semantically, this stands for a tuple of any number of types.
typing.ParamSpec , introduced by a name prefixed with two asterisks (e.g., **P ). Semantically, this stands for the parameters of a callable.

typing.TypeVar declarations can define bounds and constraints with a colon ( : ) followed by an expression. A single expression after the colon indicates a bound (e.g. T: int ). Semantically, this means that the typing.TypeVar can only represent types that are a subtype of this bound. A parenthesized tuple of expressions after the colon indicates a set of constraints (e.g. T: (str, bytes) ). Each member of the tuple should be a type (again, this is not enforced at runtime). Constrained type variables can only take on one of the types in the list of constraints.

For typing.TypeVar s declared using the type parameter list syntax, the bound and constraints are not evaluated when the generic object is created, but only when the value is explicitly accessed through the attributes __bound__ and __constraints__ . To accomplish this, the bounds or constraints are evaluated in a separate annotation scope .

typing.TypeVarTuple s and typing.ParamSpec s cannot have bounds or constraints.

The following example indicates the full set of allowed type parameter declarations:

def overly_generic[
   SimpleTypeVar,
   TypeVarWithBound: int,
   TypeVarWithConstraints: (str, bytes),
   *SimpleTypeVarTuple,
   **SimpleParamSpec,
](
   a: SimpleTypeVar,
   b: TypeVarWithBound,
   c: Callable[SimpleParamSpec, TypeVarWithConstraints],
   *d: SimpleTypeVarTuple,
): ...

8.10.1. Generic functions ¶

Generic functions are declared as follows:

def func[T](arg: T): ...

This syntax is equivalent to:

annotation-def TYPE_PARAMS_OF_func():
    T = typing.TypeVar("T")
    def func(arg: T): ...
    func.__type_params__ = (T,)
    return func
func = TYPE_PARAMS_OF_func()

这里 annotation-def indicates an annotation scope , which is not actually bound to any name at runtime. (One other liberty is taken in the translation: the syntax does not go through attribute access on the typing module, but creates an instance of typing.TypeVar directly.)

The annotations of generic functions are evaluated within the annotation scope used for declaring the type parameters, but the function’s defaults and decorators are not.

The following example illustrates the scoping rules for these cases, as well as for additional flavors of type parameters:

@decorator
def func[T: int, *Ts, **P](*args: *Ts, arg: Callable[P, T] = some_default):
    ...

Except for the lazy evaluation 的 TypeVar bound, this is equivalent to:

DEFAULT_OF_arg = some_default
annotation-def TYPE_PARAMS_OF_func():
    annotation-def BOUND_OF_T():
        return int
    # In reality, BOUND_OF_T() is evaluated only on demand.
    T = typing.TypeVar("T", bound=BOUND_OF_T())
    Ts = typing.TypeVarTuple("Ts")
    P = typing.ParamSpec("P")
    def func(*args: *Ts, arg: Callable[P, T] = DEFAULT_OF_arg):
        ...
    func.__type_params__ = (T, Ts, P)
    return func
func = decorator(TYPE_PARAMS_OF_func())

The capitalized names like DEFAULT_OF_arg are not actually bound at runtime.

8.10.2. Generic classes ¶

Generic classes are declared as follows:

class Bag[T]: ...

This syntax is equivalent to:

annotation-def TYPE_PARAMS_OF_Bag():
    T = typing.TypeVar("T")
    class Bag(typing.Generic[T]):
        __type_params__ = (T,)
        ...
    return Bag
Bag = TYPE_PARAMS_OF_Bag()

Here again annotation-def (not a real keyword) indicates an annotation scope , and the name TYPE_PARAMS_OF_Bag is not actually bound at runtime.

Generic classes implicitly inherit from typing.Generic . The base classes and keyword arguments of generic classes are evaluated within the type scope for the type parameters, and decorators are evaluated outside that scope. This is illustrated by this example:

@decorator
class Bag(Base[T], arg=T): ...

这相当于：

annotation-def TYPE_PARAMS_OF_Bag():
    T = typing.TypeVar("T")
    class Bag(Base[T], typing.Generic[T], arg=T):
        __type_params__ = (T,)
        ...
    return Bag
Bag = decorator(TYPE_PARAMS_OF_Bag())

8.10.3. Generic type aliases ¶

The type statement can also be used to create a generic type alias:

type ListOrSet[T] = list[T] | set[T]

Except for the lazy evaluation of the value, this is equivalent to:

annotation-def TYPE_PARAMS_OF_ListOrSet():
    T = typing.TypeVar("T")
    annotation-def VALUE_OF_ListOrSet():
        return list[T] | set[T]
    # In reality, the value is lazily evaluated
    return typing.TypeAliasType("ListOrSet", VALUE_OF_ListOrSet(), type_params=(T,))
ListOrSet = TYPE_PARAMS_OF_ListOrSet()

这里， annotation-def (not a real keyword) indicates an annotation scope . The capitalized names like TYPE_PARAMS_OF_ListOrSet are not actually bound at runtime.

脚注

[ 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

以下标准库类是序列：

注意

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

8.4.1. `except` clause ¶

8.4.2. `except*` clause ¶

8.4.3. `else` clause ¶

8.4.4. `finally` clause ¶

8.6.3. Irrefutable Case Blocks ¶

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 ¶

内容表

上一话题

下一话题

本页

快速搜索