
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 `list` is a mutable, ordered sequence of items. You create one with square brackets (`[1, 2, 3]`) or by calling `list(iterable)`. Lists grow with `.append()` and `.extend()`, shrink with `.pop()` and `.remove()`, and can be sliced with `xs[start:stop]`.

<ExamplePair>
<ExampleProse>

The most common list operations: `.append(x)` adds one item to the end, `.extend(iterable)` appends every item from another iterable, `.insert(i, x)` inserts at a specific index, `.pop()` removes and returns the last item, and `.remove(x)` removes the first occurrence of a value. Appending and popping at the right end (index -1) is O(1) - fast regardless of list size. Inserting or removing at the left end (index 0) is O(n) because every other item must shift.

</ExampleProse>
<ExampleCode>

```python
xs = [1, 2, 3]

xs.append(4)        # [1, 2, 3, 4]
xs.extend([5, 6])   # [1, 2, 3, 4, 5, 6]
xs.insert(0, 0)     # [0, 1, 2, 3, 4, 5, 6]  -- O(n), shifts everything
xs.pop()            # returns 6, list is [0, 1, 2, 3, 4, 5]
xs.remove(0)        # removes first 0, list is [1, 2, 3, 4, 5]

len(xs)             # 5
3 in xs             # True
xs.index(3)         # 2  (position of the value 3)
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

Slicing returns a new list containing the selected items. `xs[a:b]` gives items from index `a` up to (but not including) `b`. Negative indices count from the end: `xs[-1]` is the last item. `xs[::-1]` steps backwards and returns a reversed copy. `xs[:]` copies the entire list shallowly - useful when you need a separate list that starts with the same values.

</ExampleProse>
<ExampleCode>

```python
xs = [10, 20, 30, 40, 50]

xs[1:3]     # [20, 30]          -- items at index 1 and 2
xs[:2]      # [10, 20]          -- first two
xs[2:]      # [30, 40, 50]      -- from index 2 to end
xs[-1]      # 50                -- last item
xs[::-1]    # [50, 40, 30, 20, 10]  -- reversed copy
xs[:]       # [10, 20, 30, 40, 50]  -- shallow copy

copy = xs[:]
copy.append(99)
xs   # [10, 20, 30, 40, 50]  -- original unchanged
```

</ExampleCode>
</ExamplePair>

<ExamplePair>
<ExampleProse>

`[[]] * n` looks like it creates `n` independent empty lists, but it actually creates `n` references to the same inner list. Appending to any one of them mutates all of them. The fix is a list comprehension: `[[] for _ in range(n)]` calls `[]` once per iteration, producing `n` distinct list objects.

</ExampleProse>
<ExampleCode>

```python
# Bug: all three rows point to the same list
grid = [[]] * 3
grid[0].append(1)
grid  # [[1], [1], [1]]  -- all three changed!

# Fix: comprehension creates a new [] each iteration
grid = [[] for _ in range(3)]
grid[0].append(1)
grid  # [[1], [], []]  -- only row 0 changed

# Same trap with any mutable default
row = [0] * 5     # [0, 0, 0, 0, 0]  -- safe: ints are immutable
matrix = [[0] * 5 for _ in range(3)]  # correct 3x5 grid
```

</ExampleCode>
</ExamplePair>

<InProduction>
`[[]] * n` creates n references to the same inner list - appending to one mutates all of them. Use `[[] for _ in range(n)]` instead. Lists are O(1) for `.append()` and `.pop()` at the right end but O(n) for `.pop(0)` and `.insert(0, x)` because every item must shift; for FIFO queues reach for `collections.deque`, which is O(1) at both ends.
</InProduction>


Python list basics: append, extend, slicing, shallow copies, and the shared-reference trap with [[]] * n.

Lists


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+).