Conditionals, Loops, Loop Control & match-case

Control flow in Python determines how the VM branches execution paths. Beyond standard if/elif/else conditionals and while/for loops, modern Python features Structural Pattern Matching (match/case) introduced in PEP 634 and the often misunderstood Loop else clause.

This chapter details CPython bytecode branching, Structural Pattern Matching AST destructuring, and loop control semantics.

1. Structural Pattern Matching Mechanics (`match/case`)

match/case is not a simple C-style switch statement that evaluates integer values. It is a full destructuring pattern engine that matches values, types, and sequence structures at runtime:

Structural Pattern Matching Execution Pipeline:

[ Subject Value (e.g. command = ["MOVE", 10, 20]) ]
                         |
                         v
[ Case 1: Sequence Destructuring match ["MOVE", x, y] ]
     ├─ Type Check: Is subject a Sequence? (Yes)
     ├─ Length Check: Does len == 3? (Yes)
     ├─ Constant Match: Does subject[0] == "MOVE"? (Yes)
     └─ Variable Binding: Bind x = 10, y = 20
                         |
                         v
[ Match Succeeded! Execute Case Block ]

Pattern Matching Types:

Literal Pattern: case 200: matches exact values.
Sequence Pattern: case [x, y, *rest]: matches lists/tuples and captures remaining items.
Mapping Pattern: case {"action": "build", "id": item_id}: matches dictionary key structures.
Class Pattern: case Point(x=x, y=y): checks isinstance() and attributes via __match_args__.
Guard Expressions: case x if x > 0: adds boolean conditional guards to matching patterns.

2. Loop `else` Clause Execution Rules

Python allows adding an else block to for and while loops. The execution rule is strict:

The loop else block executes IF AND ONLY IF the loop completes naturally without encountering a break statement.

def find_target(items, target):
    for item in items:
        if item == target:
            print("Found target!")
            break  # Exits loop IMMEDIATELY -> 'else' block is SKIPPED!
    else:
        # Executes ONLY if the loop ran to completion without hitting 'break'
        print("Target not found in sequence.")

3. Bytecode Branching (`POP_JUMP_IF_FALSE`)

At the bytecode level, if/else statements compile into comparison instructions followed by conditional jump opcodes:

COMPARE_OP: Compares stack values.
POP_JUMP_IF_FALSE (target_offset): Pops the comparison boolean off the evaluation stack. If False, jumps execution directly to the specified bytecode instruction offset.

4. Production Trade-offs & Style Boundaries

match/case vs if/elif: Use match/case when destructuring complex nested JSON or class objects. Avoid match/case for simple integer/string equality checks where standard dictionary mapping lookups (handler_dict[cmd]()) are cleaner.
Nested Loops: Deeply nested loops with multiple break flags increase cyclomatic complexity. Refactor nested searches into helper generator functions using return.

⚡

Revision Mode Active Condensed for 5-minute review. Focused on 30-second pitches, mental anchors, and high-frequency interview traps.

⚡ 30-Second Elevator Pitch

“Python control flow uses bytecode jump opcodes (POP_JUMP_IF_FALSE) for branching. Structural Pattern Matching (match/case) performs runtime type checking, sequence destructuring, and variable binding. Loop else blocks execute exclusively when a loop runs to natural completion without hitting a break statement.”

🧠 Under The Hood & Mental Model

Pattern Destructuring: match/case checks isinstance(), sequence lengths, and mapping keys simultaneously before binding variables.
Loop else Invariant: Thinks of loop else as “nobreak” — it runs when no break triggered inside the loop body.
POP_JUMP_IF_FALSE: CPython opcode that alters the bytecode execution pointer based on stack evaluation.
__match_args__: Class attribute that defines positional parameter matching order for custom objects in match/case.

💻 High-Yield Code & Gotcha

# ❌ ANTI-PATTERN: Flag variables for search loops
found = False
for item in items:
    if item.is_valid():
        found = True
        process(item)
        break

if not found:
    handle_missing()

# ✅ PRODUCTION PATTERN: Clean Loop 'else' Clause
for item in items:
    if item.is_valid():
        process(item)
        break
else:
    handle_missing()  # Executes cleanly when no item matched!

⚠️ GOTCHA: Variable Capture in `match/case`

In match/case, writing case my_constant: does NOT check if the subject equals the value of my_constant. It creates a new variable variable binding named my_constant that matches everything! To match against constants, use qualified names (case Constants.MY_VAL:) or Guard expressions.

⚖️ Trade-Offs & Comparison

+ match/case: Eliminates verbose type assertions and nested indexing when processing heterogeneous data structures.
- match/case: Slightly higher AST parsing and execution overhead than a direct dict lookup.

🌟 My Experience (STAR Anchor)

“A webhook parser contained 150 lines of brittle, nested isinstance() checks and dictionary lookups to handle event types. I refactored the dispatcher to use Structural Pattern Matching with class patterns, reducing code length by 60% and catching malformed webhook schemas at the pattern match boundary.”

Python Interview Handbook

Conditionals, Loops, Loop Control & match-case

1. Structural Pattern Matching Mechanics (`match/case`)

Pattern Matching Types:

2. Loop `else` Clause Execution Rules

3. Bytecode Branching (`POP_JUMP_IF_FALSE`)

4. Production Trade-offs & Style Boundaries

⚡ 30-Second Elevator Pitch

🧠 Under The Hood & Mental Model

💻 High-Yield Code & Gotcha

⚠️ GOTCHA: Variable Capture in `match/case`

⚖️ Trade-Offs & Comparison

🌟 My Experience (STAR Anchor)

When does the `else` block attached to a `for` loop in Python execute?

No Interactive Questions Yet

Conditionals, Loops, Loop Control & match-case

1. Structural Pattern Matching Mechanics (match/case)

Pattern Matching Types:

2. Loop else Clause Execution Rules

3. Bytecode Branching (POP_JUMP_IF_FALSE)

4. Production Trade-offs & Style Boundaries

⚡ 30-Second Elevator Pitch

🧠 Under The Hood & Mental Model

💻 High-Yield Code & Gotcha

⚠️ GOTCHA: Variable Capture in match/case

⚖️ Trade-Offs & Comparison

🌟 My Experience (STAR Anchor)

When does the `else` block attached to a `for` loop in Python execute?

No Interactive Questions Yet

1. Structural Pattern Matching Mechanics (`match/case`)

2. Loop `else` Clause Execution Rules

3. Bytecode Branching (`POP_JUMP_IF_FALSE`)

⚠️ GOTCHA: Variable Capture in `match/case`