
Python's branching uses `if`, `elif`, and `else`. For a quick inline choice there is the conditional expression (`a if condition else b`). Since Python 3.10 there is also structural pattern matching with `match` and `case`, which matches on the shape and contents of a value rather than just equality.

<ExamplePair>
<ExampleProse>

An `if`/`elif`/`else` chain evaluates each condition in order and runs the first branch that is true. `elif` is short for "else if" - you can have as many as you need. The `else` branch runs when no earlier condition matched.

</ExampleProse>
<ExampleCode>

```python
def classify_status(code: int) -> str:
    if code < 200:
        return "informational"
    elif code < 300:
        return "success"
    elif code < 400:
        return "redirect"
    elif code < 500:
        return "client error"
    else:
        return "server error"

classify_status(200)  # 'success'
classify_status(404)  # 'client error'
classify_status(503)  # 'server error'
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

The conditional expression (`value_if_true if condition else value_if_false`) fits a two-way choice on one line. It is useful for short, readable choices. Nesting conditional expressions inside one another is a code-review smell - use a regular `if`/`else` block instead.

</ExampleProse>
<ExampleCode>

```python
n = 7
label = "even" if n % 2 == 0 else "odd"
label  # 'odd'

# Readable: one level deep
status = "active" if user.is_logged_in else "guest"

# Avoid: nested ternaries are hard to read at a glance
# result = "a" if x else ("b" if y else "c")  -- use if/elif/else
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`match`/`case` (Python 3.10+) is structural pattern matching - it inspects the shape and contents of a value, not just its equality. A `case` clause can destructure a dict, pull out fields by name, and bind them as local variables in one step. One important detail: `case x:` with a bare name always binds (it never compares), so use a dotted name like `case Color.RED:` to compare against a constant.

</ExampleProse>
<ExampleCode>

```python
def handle(event: dict) -> str:
    match event:
        case {"type": "click", "x": x, "y": y}:
            return f"click at ({x}, {y})"
        case {"type": "keypress", "key": key}:
            return f"key: {key}"
        case {"type": str(t)}:
            return f"unknown event type: {t}"
        case _:
            return "malformed event"

handle({"type": "click", "x": 10, "y": 20})   # 'click at (10, 20)'
handle({"type": "keypress", "key": "Enter"})   # 'key: Enter'
```

</ExampleCode>
</ExamplePair>

<InProduction>
`match` is structural pattern matching, not a C-style switch - it matches shape, not just equality. Reach for it on tagged dicts, parsed JSON, AST nodes, and message envelopes where you want to destructure and bind fields in one step; for plain equality dispatch a chain of `elif` is clearer. `case x:` with a bare name binds rather than compares - use a dotted name (`case Color.RED:`) or a guard (`case x if x == sentinel:`) when you need literal comparison.
</InProduction>


Python branching with if/elif/else, conditional expressions, and structural pattern matching with match/case (3.10+).

Conditionals


Python has two loop forms: `for` iterates over a collection or range, and `while` runs as long as a condition is true. Both support `break` (exit early) and `continue` (skip to the next iteration). Both also accept an `else` clause - uncommon but worth knowing.

<ExamplePair>
<ExampleProse>

`for x in xs:` works with any iterable - lists, ranges, strings, dicts, files. `range(n)` produces integers 0 through n-1. `enumerate(xs)` gives you each item paired with its index, removing the need for a separate counter. `zip(a, b)` steps through two iterables in parallel, pairing items at the same position.

</ExampleProse>
<ExampleCode>

```python
fruits = ["apple", "banana", "cherry"]

# Basic for loop
for fruit in fruits:
    print(fruit)

# range: 0, 1, 2, 3, 4
for i in range(5):
    print(i)

# enumerate: index + value
for i, fruit in enumerate(fruits):
    print(i, fruit)   # 0 apple, 1 banana, 2 cherry

# zip: iterate two lists in parallel
prices = [1.20, 0.50, 2.00]
for fruit, price in zip(fruits, prices):
    print(f"{fruit}: ${price:.2f}")
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`while` runs as long as its condition is true. Use `break` to exit early when a goal is reached, and `continue` to skip the rest of the loop body for the current iteration. A `while True:` loop with an explicit `break` is a common pattern for "keep reading until a sentinel value."

</ExampleProse>
<ExampleCode>

```python
# Read lines until the user types "quit"
lines = []
while True:
    line = input("> ")
    if line == "quit":
        break
    lines.append(line)

print(f"Collected {len(lines)} line(s)")

# continue: skip blank lines
for line in lines:
    if not line.strip():
        continue
    process(line)
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Both `for` and `while` accept an optional `else` clause. The `else` block runs when the loop finishes normally - that is, without hitting a `break`. It reads as "no early exit occurred." Most teams avoid this because readers unfamiliar with Python expect `else` to mean "condition was false," not "loop completed." A sentinel variable is usually clearer.

</ExampleProse>
<ExampleCode>

```python
# for/else: runs the else block only when break was never hit
def find(items: list, target: int) -> str:
    for item in items:
        if item == target:
            break
    else:
        return "not found"
    return f"found {target}"

find([1, 2, 3], 2)  # 'found 2'
find([1, 2, 3], 9)  # 'not found'

# Same logic, clearer with a sentinel variable
def find_v2(items: list, target: int) -> str:
    found = False
    for item in items:
        if item == target:
            found = True
            break
    return f"found {target}" if found else "not found"
```

</ExampleCode>
</ExamplePair>

<InProduction>
The `for`/`else` clause runs when the loop exits without `break` - it reads as "no match found." Most teams use a sentinel variable instead because `else` on a loop is widely misunderstood and will surprise reviewers unfamiliar with Python. Modifying a list while iterating it (`for x in xs: xs.remove(x)`) skips elements because the iterator's position shifts after each removal; iterate over a copy (`for x in xs[:]:`) or build a new list with a comprehension.
</InProduction>


Python for and while loops, enumerate and zip for cleaner iteration, break and continue, and the for/else clause.

Loops


A Python `bool` is one of two values: `True` or `False`. Comparisons (`==`, `<`, `in`) and logical operators (`and`, `or`, `not`) produce booleans. Beyond the two bool literals, many other values behave as true or false in a boolean context - this is called "truthiness."

<ExamplePair>
<ExampleProse>

`bool(x)` converts any value to its boolean equivalent. The falsy values are: `0`, `0.0`, `""`, `b""`, `[]`, `()`, `{}`, `set()`, and `None`. Every other value is truthy. You can rely on this in `if` conditions without calling `bool()` explicitly.

</ExampleProse>
<ExampleCode>

```python
# All falsy
bool(0)     # False
bool("")    # False
bool([])    # False
bool({})    # False
bool(None)  # False

# All truthy
bool(1)         # True
bool("hello")   # True
bool([0])       # True  - a list with one item, even if the item is 0
bool(0.001)     # True
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`and` and `or` do not necessarily return `True` or `False` - they return one of their operands. `or` returns the first truthy operand (or the last operand if all are falsy). `and` returns the first falsy operand (or the last operand if all are truthy). This short-circuit behaviour is useful for defaults, but it also creates a common footgun.

</ExampleProse>
<ExampleCode>

```python
# or returns the first truthy value
0 or "fallback"         # 'fallback'
"primary" or "fallback" # 'primary'
[] or [1, 2]            # [1, 2]

# and returns the first falsy value
1 and 2                 # 2   (all truthy, returns last)
0 and "unreachable"     # 0   (0 is falsy, short-circuits)

# Footgun: silently uses the fallback when 0 or "" is a valid value
count = 0
display = count or "no items"   # 'no items' -- wrong when count is a valid 0
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`is` checks identity - whether two names refer to the same object in memory. `==` checks value equality. For `None`, `is` is the canonical idiom and is faster. For `True` and `False`, use truthiness (`if x:`) rather than `is True` or `is False` - they are fragile if the value is a truthy non-bool.

</ExampleProse>
<ExampleCode>

```python
x = None
x is None       # True  - canonical None check
x == None       # True  - works, but non-idiomatic

# is True / is False are footguns
result = 1      # truthy, but not the bool True
result == True  # True
result is True  # False  - 1 and True are different objects

# Prefer plain truthiness checks
if result:       # idiomatic - "do I have a value?"
    pass
if result is not None:  # idiomatic - "was something provided?"
    pass
```

</ExampleCode>
</ExamplePair>

<InProduction>
`if my_list:` treats empty containers as false - convenient for "do I have items?", but catastrophic when `0`, `""`, or `[]` is a legitimate value (a counter starting at zero, an empty form field, a response body that is intentionally empty). Use `if x is not None:` when the distinction between "absent" and "falsy but present" matters. `and`/`or` return operands not booleans, so `default = config_value or "fallback"` silently uses the fallback for `0`, `""`, and `[]`.
</InProduction>


Python bool - True and False, truthy and falsy values, short-circuit operators, and when to use is vs ==.