Control Flow

Python expresses branching with if/elif/else, structural matching with match/case, and iteration with for and while. Loop else clauses and short-circuit boolean operators are idioms worth learning early.

Recipe

for index, item in enumerate(["a", "b", "c"], start=1):
    if item == "b":
        continue
    print(index, item)
 
match status:
    case 200:
        print("ok")
    case 404 | 410:
        print("missing")
    case code if 500 <= code < 600:
        print("server error")

When to reach for this:

• Branching on enums, HTTP codes, or command types
• Destructuring nested JSON-like data with match
• Scanning sequences with early exit (break)
• Combining multiple iterables with zip

Working Example

from dataclasses import dataclass
 
@dataclass
class Event:
    kind: str
    payload: dict[str, object]
 
def handle(event: Event) -> str:
    match event:
        case Event(kind="user.created", payload={"id": int(uid), "email": str(email)}):
            return f"provision {uid} for {email}"
        case Event(kind="user.deleted", payload={"id": int(uid)}):
            return f"cleanup {uid}"
        case Event(kind=k):
            return f"ignored {k}"
        case _:
            return "unknown"
 
def find_first_negative(nums: list[int]) -> int | None:
    for n in nums:
        if n < 0:
            return n
    else:
        return None  # no break occurred
 
def main() -> None:
    events = [
        Event("user.created", {"id": 1, "email": "a@example.com"}),
        Event("order.placed", {"id": 99}),
    ]
    for ev in events:
        print(handle(ev))
    print(find_first_negative([1, 2, 3]))
 
if __name__ == "__main__":
    main()

What this demonstrates:

• match binds variables (uid, email) while matching dict structure
• Class patterns combine type and attribute constraints
• for/else returns a sentinel when no break fires
• continue skips to the next iteration without exiting the loop

Deep Dive

How It Works

• Truthiness drives if - Objects implement __bool__ or __len__.
• Pattern matching - Introduced in 3.10; cases are checked top to bottom; first match wins.
• Short-circuit - a and b evaluates b only if a is truthy; a or b skips b if a is truthy.
• Iteration protocol - for calls iter() then repeated next() until StopIteration.
• while else - Same semantics as for else - runs when loop ends without break.

match Features at a Glance

Python Notes

# walrus := assigns inside expressions (3.8+)
if (line := input()) == "quit":
    pass
 
# zip strict=True (3.10+) raises on unequal lengths
for a, b in zip(xs, ys, strict=True):
    ...

Gotchas

• Missing break in while True - Infinite loops hang workers. Fix: Explicit break condition or timeout.
• match fall-through - No automatic fall-through between cases (unlike C switch). Fix: Combine with | or shared logic.
• Loop else confusion - else runs when no break, not on falsy condition. Fix: Comment intent or refactor to functions.
• Modifying list while iterating - Skips elements or raises errors. Fix: Iterate a copy or build a new list.
• Truthy empty containers - [0] is truthy because non-empty. Fix: Compare lengths or values explicitly when needed.

Alternatives

FAQs

Related

• Comprehensions & Generator Expressions - loop-free iteration
• Functions, Args & Scope - early return instead of deep nesting
• Enums - match on enum members
• Dunder / Magic Methods - customizing truthiness

Stack versions: This page was written for Python 3.14.0 (stable 3.14, maintenance 3.13), FastAPI 0.115+, Django 5.2, Flask 3.1, Pydantic 2, PyTorch 2.6+, pandas 2.2+, Polars 1.x, ruff 0.9+, and uv 0.6+.