8. 複合陳述式¶
Compound statements contain (groups of) other statements; they affect or control the execution of those other statements in some way. In general, compound statements span multiple lines, although in simple incarnations a whole compound statement may be contained in one line.
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)
Summarizing:
compound_stmt:if_stmt|while_stmt|for_stmt|try_stmt|with_stmt|match_stmt|funcdef|classdef|async_with_stmt|async_for_stmt|async_funcdefsuite:stmt_listNEWLINE | NEWLINE INDENTstatement+ DEDENT statement:stmt_listNEWLINE |compound_stmtstmt_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 陳述式¶
The if statement is used for conditional execution:
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 Boolean operations 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 陳述式¶
The while statement is used for repeated execution as long as an
expression is true:
while_stmt: "while"assignment_expression":"suite["else" ":"suite]
This repeatedly tests the expression and, if it is true, executes the first
suite; if the expression is false (which may be the first time it is tested) the
suite of the else clause, if present, is executed and the loop
terminates.
A break statement executed in the first suite terminates the loop
without executing the else clause's suite. A continue
statement executed in the first suite skips the rest of the suite and goes back
to testing the expression.
8.3. 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_expression_list":"suite["else" ":"suite]
The starred_expression_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 statement executed in the first suite terminates the loop
without executing the else clause's suite. A 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. try 陳述式¶
The try statement specifies exception handlers and/or cleanup code
for a group of statements:
try_stmt:try1_stmt|try2_stmt|try3_stmttry1_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
Additional information on exceptions can be found in section 例外,
and information on using the raise statement to generate exceptions
may be found in section raise 陳述式.
在 3.14 版的變更: Support for optionally dropping grouping parentheses when using multiple exception types. See PEP 758.
8.4.1. except 子句¶
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