Control Flow and Patterns

Pick one path from ordered conditions

The if statement exists to choose exactly one branch out of several, and its shape is deliberately loose: an if statement can contain zero or more elif clauses, and its else clause is optional.

>>> x = int(input("Please enter an integer: "))
Please enter an integer: 42
>>> if x < 0:
...     x = 0
...     print('Negative changed to zero')
... elif x == 0:
...     print('Zero')
... elif x == 1:
...     print('Single')
... else:
...     print('More')
...
More

The conditions are tested in order, and the first true one wins. elif is short for "else if" and keeps a long chain from drifting further and further to the right. A chain of if … elif … elif … does the work that a switch or case statement does in other languages.

Loop over the items, not over a counter

Python's for statement is not the counter-driven loop of C or Pascal. It iterates over the items of a sequence — a list, a string — in the order in which they appear. There is no start value to set and no halting condition to maintain:

>>> words = ['cat', 'window', 'defenestrate']
>>> for w in words:
...     print(w, len(w))
...
cat 3
window 6
defenestrate 12

The loop asks the sequence for its next item and stops when the supply runs out. That is why a for loop reads like a sentence about the data rather than a sentence about indices.

One habit is worth building early. Code that modifies a collection while iterating over that same collection is tricky to get right, and the two documented ways out are to iterate over a copy or to build a new collection:

users = {'Hans': 'active', 'Éléonore': 'inactive', '景太郎': 'active'}

# Iterate over a copy
for user, status in users.copy().items():
    if status == 'inactive':
        del users[user]

# Create a new collection
active_users = {}
for user, status in users.items():
    if status == 'active':
        active_users[user] = status

Both keep the thing being walked separate from the thing being changed.

Generate numbers with range()

When you really do need a sequence of numbers, range() generates an arithmetic progression. The rule that governs every one of them: the given end point is never part of the generated sequence.

>>> for i in range(5):
...     print(i)
...
0
1
2
3
4

range(10) therefore produces ten values — exactly the legal indices of a ten-item sequence. It also accepts an alternative start and a step, and the step may be negative:

Printing a range shows something surprising: range(10) displays as range(0, 10), not as a list of numbers. In many ways the object behaves like a list, but it is not one. It returns the successive values when you iterate over it without ever building the corresponding list, which saves space.

For walking the positions of a sequence, range() can be combined with len():

>>> a = ['Mary', 'had', 'a', 'little', 'lamb']
>>> for i in range(len(a)):
...     print(i, a[i])
...
0 Mary
1 had
2 a
3 little
4 lamb

In most such cases, though, enumerate() is the more convenient choice, because it hands you the position and the item together instead of making you index back into the sequence.

Leave a loop early with break

Some searches are finished before the data is. The break statement breaks out of the innermost enclosing for or while loop — one loop, the nearest one, and nothing beyond it.

>>> for n in range(2, 10):
...     for x in range(2, n):
...         if n % x == 0:
...             print(f"{n} equals {x} * {n//x}")
...             break
...
4 equals 2 * 2
6 equals 2 * 3
8 equals 2 * 4
9 equals 3 * 3

Read what that break did. It ended the inner loop over candidate divisors as soon as one was found, and the outer loop over n carried on to the next number. Choosing which loop a break sits in is therefore how you decide how much work gets abandoned.

Skip the rest of one pass with continue

Where break abandons the loop, continue continues with the next iteration of the loop. The remainder of the current pass is skipped; the loop itself survives.

>>> for num in range(2, 10):
...     if num % 2 == 0:
...         print(f"Found an even number {num}")
...         continue
...     print(f"Found an odd number {num}")
...
Found an even number 2
Found an odd number 3
Found an even number 4
Found an odd number 5

The two statements are easy to tell apart once you name what each one discards:

The clause that means "we got to the end"

A for or while loop may carry an else clause, and it runs when the loop finishes without executing break. What "finishing" means depends on the loop:

A break skips the else — and so does any other early exit, such as a return or a raised exception.

That makes the loop's else the natural home for a "we looked everywhere" message. The prime search below prints its verdict only for numbers whose inner loop ran out of divisors:

>>> for n in range(2, 10):
...     for x in range(2, n):
...         if n % x == 0:
...             print(n, 'equals', x, '*', n//x)
...             break
...     else:
...         # loop fell through without finding a factor
...         print(n, 'is a prime number')
...
2 is a prime number
3 is a prime number
4 equals 2 * 2
5 is a prime number

Look closely: that else belongs to the for loop, not to the if. It expresses successful exhaustion, not the false branch of a condition — it has more in common with the else of a try statement, which runs when no exception occurred.

Hold a place with pass

Sometimes the grammar demands a statement and the program has nothing to do there. The pass statement performs no action, and it exists to satisfy a position where a statement is required syntactically.

That covers three everyday situations: an empty class, a function whose body is still to be written, and a conditional branch left deliberately blank.

>>> class MyEmptyClass:
...     pass
...
>>> def initlog(*args):
...     pass  # Remember to implement this!
...

pass is silently ignored when it runs, which is what lets you keep sketching a structure at a high level and fill the bodies in later. It is not a loop control statement and it does not return anything.

Match a subject against successive patterns

A match statement takes a subject value and compares it against successive case patterns. Two rules govern the outcome: only the first pattern that matches is executed, and if nothing matches, no branch runs at all.

def http_error(status):
    match status:
        case 400:
            return "Bad request"
        case 404:
            return "Not found"
        case 418:
            return "I'm a teapot"
        case _:
            return "Something's wrong with the internet"

Note the last block. The standalone name _ is a wildcard pattern that never fails to match, which is how a match statement is given a catch-all ending.

Several literal alternatives can share a single case when they are joined with |, read as "or":

        case 401 | 403 | 404:
            return "Not allowed"

One more comparison rule is worth memorising before the patterns get more elaborate: most literals are compared by equality, but the singletons True, False and None are compared by identity.

Take the subject apart

Patterns do more than recognise a value: they can decompose data. A sequence-like pattern can bind selected components to standalone variable names, so recognising and extracting happen in the same line:

match point:
    case (0, 0):
        print("Origin")
    case (0, y):
        print(f"Y={y}")
    case (x, 0):
        print(f"X={x}")
    case (x, y):
        print(f"X={x}, Y={y}")
    case _:
        raise ValueError("Not a point")

Only standalone names are assigned by a match statement. That is the reason for one small rule with big consequences: a named constant used in a pattern must be written as a dotted name, such as Color.RED, or Python reads the bare name as a capture variable and the case matches everything.

Mapping patterns capture named values out of a dictionary, and — unlike sequence patterns — extra keys are ignored:

match config:
    case {"bandwidth": b, "latency": l}:
        print(b, l)

A dictionary carrying additional keys still matches, which is exactly what you want for data whose shape may grow.

A pattern can also carry an if clause, known as a guard. If the guard is false, matching goes on to try the next case, and the captured values are bound before the guard is evaluated — which is what lets the guard talk about them:

match point:
    case Point(x, y) if x == y:
        print(f"Y=X at {x}")
    case Point(x, y):
        print(f"Not on the diagonal")

A false guard is not an error and it does not end the statement: it simply declines this case and hands the subject to the next one.

Key takeaways

• if chooses one ordered path: zero or more elif clauses, an optional else, and the first true condition wins.
• for consumes the items of a sequence in their existing order; to change a collection safely, loop over a copy or build a new one.
• range() supplies integer progressions with an excluded end point, an optional start and step, and no list is built along the way.
• break exits the innermost enclosing loop, while continue only advances that loop to its next iteration.
• A loop's else means exhaustion without break — and a return or a raised exception skips it too.
• pass supplies a statement without taking action, keeping an empty class, function or branch valid.
• match tests cases in order, runs at most one, and combines wildcards, alternatives joined with |, captures, guards and mapping patterns.