.PY File Format – Statements

Forms of statement

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

Simple statements on one line are separated by semicolons. A compound statement has a header ending in a colon and a suite, either an indented block or simple statements on the same line. A suite on the header's line cannot itself be compound, so if a: if b: c is an error.

Expression statements

An expression can be used as a statement, normally to call a function for its effect (7.1). The value is discarded, except at the interactive prompt, which prints it unless it is None.

Assignment

assignment_stmt: (target_list "=")+ (starred_expression | yield_expression)
target_list:     target ("," target)* [","]
target:          identifier | "(" [target_list] ")" | "[" [target_list] "]"
               | attributeref | subscription | "*" target

The right-hand side is evaluated first, once. The result is then assigned to each target list from left to right (7.2).

a = b = []             # one list, two names
x, y = 1, 2            # unpacking
x, y = y, x            # swap
first, *rest = [1, 2, 3]       # 1, [2, 3]
[p, *q, r] = 1, 2, 3, 4        # 1, [2, 3], 4
*a, = 1, 2                     # [1, 2]
(a, b), c = (1, 2), 3          # nested

i = 0
x = [0, 0]
i, x[i] = 1, 2         # i becomes 1 first, so x[1] is set
x                      # [0, 2]

A starred name must be inside a list or tuple of targets, so *a = 1, 2 is an error. A length mismatch raises ValueError.

augmented_assignment_stmt: augtarget augop (expression_list | yield_expression)
augop: "+=" | "-=" | "*=" | "@=" | "/=" | "//=" | "%=" | "**="
     | ">>=" | "<<=" | "&=" | "^=" | "|="

c = [1, 2]
d = c
d += [3]
c                     # [1, 2, 3]: same list

e = (1,)
f = e
f += (2,)
e                     # (1,): f is a new tuple

t = ([1],)
t[0] += [2]           # TypeError, yet t is now ([1, 2],)

annotated_assignment_stmt: augtarget ":" expression
                           ["=" (starred_expression | yield_expression)]

Other simple statements

del_stmt: "del" target_list

assert_stmt: "assert" expression ["," expression]

if __debug__:
    if not x:
        raise AssertionError(y)

return_stmt: "return" [expression_list]

type_stmt: 'type' identifier [type_params] "=" expression

type Point = tuple[float, float]
type ListOrSet[T] = list[T] | set[T]

Point.__value__       # tuple[float, float]

if

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

The conditions are tested in order until one is true, and that suite runs (8.1). If none is true, the else suite runs when present.

while

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

Repeats while the condition is true (8.2). The else suite runs once the condition is false. A break skips it.

for

for_stmt: "for" target_list "in" starred_expression_list ":" suite
          ["else" ":" suite]

Iterates over any iterable and assigns each item to the targets (8.3). The list is evaluated once, and starred items are allowed since Python 3.11.

• The loop's else suite runs when the items are used up. A break skips it.
• The targets stay bound after the loop, to the last value. If there were no items, they are not bound at all.
• Assigning to a target in the body does not affect the next item.
• A list changed while it is being looped over can skip or repeat items, so loop over a copy. Changing a dictionary's size during iteration raises RuntimeError.

for n in numbers:
    if n < 0:
        print("found", n)
        break
else:
    print("no negative numbers")

with

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

Wraps a suite in a context manager, whose __exit__ runs however the suite ends (8.5, PEP 343). A single item behaves like this code, with special method lookup on the type:

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

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

If __exit__ returns a true value, the exception is suppressed. Several items behave like nested with statements. Parentheses around the items, with a trailing comma, are allowed since Python 3.10. The contextlib module helps write context managers.

with (
    open("in.txt") as source,
    open("out.txt", "w") as target,
):
    target.write(source.read())

try

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

The try suite runs first. On an exception, the handlers are checked in order, and the first match runs (8.4). The else suite runs if the try suite finishes with no exception. The finally suite always runs last. What each form catches is on Exceptions.

• A return, break or continue inside a finally discards any exception in flight, and replaces any earlier return value. The compiler gives a SyntaxWarning for these since Python 3.14 (PEP 765).
• finally runs on the way out, so return in the try suite runs the finally suite before returning.
• A try statement cannot mix except and except* clauses.

Definitions

def and class are statements as well, covered on Functions and Classes. The asynchronous forms are on Generators and async.