.PY File Format – Expressions

Operator precedence

The table runs from the most tightly binding to the least (6.17). Operators on one row have equal precedence. A row groups left to right unless the table says otherwise.

** binds less tightly than a unary operator on its right, so 2 ** -1 is 0.5. It binds more tightly than a unary operator on its left, so -2 ** 2 is -4 (6.5).

Atoms and displays

An atom is the most basic element: a name, a literal, a bracketed form or a display (6.2). A display builds a container from its items, evaluated left to right.

Displays can unpack iterables and mappings into themselves (PEP 448, Python 3.5):

[*range(2), 2]          # [0, 1, 2]
{*"ab", "c"}            # a set of 'a', 'b', 'c'
{"x": 1, **{"y": 2}}    # {'x': 1, 'y': 2}
(1, *[2, 3])            # (1, 2, 3)

Comprehensions

A comprehension builds a container by iterating and filtering (6.2.6):

comprehension: flexible_expression for_if_clause+
for_if_clause: ['async'] 'for' target_list 'in' or_test ('if' or_test)*

Clauses read as nested statements, from left to right:

[n * m for n in (1, 2) if n for m in (3, 4)]

# does the same as
result = []
for n in (1, 2):
    if n:
        for m in (3, 4):
            result.append(n * m)

The comprehension has its own scope. Inside an async def, async for and await are allowed in comprehensions (PEP 530, Python 3.6).

lists = [[1, 2], [3]]
[*x for x in lists]           # [1, 2, 3]

dicts = [{"a": 1}, {"a": 2, "b": 3}]
{**d for d in dicts}          # {'a': 2, 'b': 3}: the last value wins

Generator expressions

A generator expression has the same clauses as a comprehension, in parentheses (6.2.7). It returns a generator that produces values on demand, instead of building a container. The parentheses can be left out if it is the only argument of a call, as in sum(x * x for x in it).

The iterable of its leftmost for is evaluated at once, while everything else waits until the generator is advanced. See Generators.

Primaries

A primary is an atom followed by any number of attribute references, subscriptions and calls (6.3).

proper_slice: [expression] ":" [expression] [":" [expression]]

f(positional, *iterable, keyword=value, **mapping)

await

await_expr: "await" primary

Suspends a coroutine until the awaited object is finished (6.4, PEP 492). It may be used only inside async def. Its operand is a primary, so await -x is an error.

Arithmetic operators

Operators on classes are defined by special methods.

Comparisons

comparison:    or_expr (comp_operator or_expr)*
comp_operator: "<" | ">" | "==" | ">=" | "<=" | "!="
               | "is" ["not"] | ["not"] "in"

Comparisons chain (6.10). a < b <= c means a < b and b <= c, with b evaluated once. The chain stops at the first false result.

Use is only for singletons such as None. The compiler gives a SyntaxWarning for is with a literal, as in x is 1. Comparison behaviour is set by the rich comparison methods.

Boolean operations

or_test:  and_test | or_test "or" and_test
and_test: not_test | and_test "and" not_test
not_test: comparison | "not" not_test

and and or evaluate only as far as needed and return the operand they stopped at, not a bool (6.11). not always returns a bool. See Truth values.

0 or "default"     # 'default'
"a" or "b"         # 'a'
"" and "b"         # ''
1 and 2            # 2
not []             # True

Assignment expressions

assignment_expression: [identifier ":="] expression

The := operator binds a name and also gives the value (6.12, PEP 572, Python 3.8). The target is a plain name, never an attribute or an item.

if (n := len(data)) > 10:
    print(f"too long: {n}")

while chunk := read():
    process(chunk)

An unparenthesised := is not valid as a statement on its own, as the right-hand side of an assignment, or for a keyword argument's value. It is allowed as a positional argument and in a list display, and in if and while headers. Its scope in a comprehension is described under Comprehension scopes.

Conditional expressions

conditional_expression: or_test ["if" or_test "else" expression]

a if c else b evaluates c first, then only one of the other two (6.13, PEP 308). It groups to the right, so a if x else b if y else c means a if x else (b if y else c).

Lambda expressions

lambda_expr: "lambda" [parameter_list] ":" expression

A lambda makes an anonymous function whose body is one expression, which is returned (6.14). It accepts every parameter kind, but it cannot have statements or annotations. Its __name__ is <lambda>.

sorted(words, key=lambda w: (len(w), w))

Expression lists and unpacking

starred_expression: "*" or_expr | expression
flexible_expression: assignment_expression | starred_expression

An expression list with a comma makes a tuple (6.15). A starred item unpacks into the list. A trailing comma is allowed, and needed for a tuple of one. The bare forms are also how a function returns several values and how a tuple assignment works.

a = 1, 2           # (1, 2)
b = *a, 3          # (1, 2, 3)
c = (5,)           # one-item tuple
d = (5)            # the integer 5

Evaluation order

Python evaluates expressions from left to right (6.16). In an assignment, the right-hand side is evaluated before the left. In these lines, the subexpressions are evaluated in the order of their numbers:

expr1, expr2, expr3, expr4
{expr1: expr2, expr3: expr4}
expr1 + expr2 * (expr3 - expr4)
expr1(expr2, expr3, *expr4, **expr5)
expr3, expr4 = expr1, expr2