S006 · Control Flow — if/else, loops, comprehensions

def describe(msg):
    match msg:
        case {"type": "ping"}:                              # dict shape
            return "pong"
        case {"type": "user", "name": name, "age": age} if age >= 18:
            return f"adult user {name}"
        case {"type": "user", "name": name}:                # binding
            return f"minor user {name}"
        case [x, y, *rest]:                                 # list shape
            return f"list starting {x},{y} + {len(rest)} more"
        case Point(x=0, y=0):                               # class pattern
            return "origin"
        case _:                                             # fallthrough
            return "unknown"

"""s006_control_flow.py — the shapes of Python control flow."""
from __future__ import annotations
from itertools import chain, groupby, islice, product
from operator import itemgetter
 
# =========================
# Part 1 · Branching menu
# =========================
print("--- Part 1 ---")
 
def grade_if(score: int) -> str:
    if score >= 90:  return "A"
    elif score >= 75: return "B"
    elif score >= 60: return "C"
    else:             return "F"
 
def grade_dict(score: int) -> str:
    # Better when you have many uniform thresholds — but this pattern gets awkward
    # for ranges. Keep if/elif for range decisions.
    return {True: "A"}[True] if score >= 90 else "…"  # illustration only
 
def grade_match(msg: dict) -> str:
    match msg:
        case {"kind": "quiz", "score": s} if s >= 90: return f"quiz A ({s})"
        case {"kind": "quiz", "score": s}:            return f"quiz other ({s})"
        case {"kind": "essay", "words": w}:           return f"essay {w} words"
        case _:                                       return "unknown"
 
print(grade_if(88))
print(grade_match({"kind": "quiz", "score": 92}))
print(grade_match({"kind": "essay", "words": 500}))
print(grade_match({"kind": "video"}))
 
# Ternary for a SINGLE value, one line
def parity(n: int) -> str: return "even" if n % 2 == 0 else "odd"
print(parity(4), parity(7))
 
# Dict-dispatch when branches are handlers
HANDLERS = {
    "ping": lambda: "pong",
    "hello": lambda: "hi",
    "quit": lambda: None,
}
def dispatch(cmd: str):
    return HANDLERS.get(cmd, lambda: f"unknown: {cmd}")()
print(dispatch("ping"), dispatch("foo"))
 
# =========================
# Part 2 · Comprehensions — the sweet spot
# =========================
print("\n--- Part 2 ---")
 
nums = range(20)
evens = [n for n in nums if n % 2 == 0]
squares_of_odds = [n*n for n in nums if n % 2]
print(evens)
print(squares_of_odds)
 
# Dict comprehension
word_lens = {w: len(w) for w in ["apple", "banana", "kiwi"]}
print(word_lens)
 
# Set comprehension — dedup while transforming
unique_first_letters = {w[0].upper() for w in ["apple", "avocado", "banana"]}
print(unique_first_letters)
 
# Nested comprehension — allowed, but STOP if it gets deeper than 2 levels
grid = [[r * 3 + c for c in range(3)] for r in range(3)]
print(grid)
 
# =========================
# Part 3 · Iteration idioms every Python dev knows
# =========================
print("\n--- Part 3 ---")
 
names = ["ada", "linus", "grace"]
 
# enumerate — index + value
for i, name in enumerate(names, start=1):
    print(f"  {i}. {name}")
 
# zip — parallel iteration
scores = [92, 88, 100]
for name, score in zip(names, scores, strict=True):   # 3.10+: strict=True asserts equal lengths
    print(f"  {name}: {score}")
 
# reversed / sorted
for name in sorted(names, key=len):
    print(" ", name)
 
# =========================
# Part 4 · Generators — lazy is powerful
# =========================
print("\n--- Part 4 ---")
 
def read_lines_lazy(n: int):
    """Yields simulated lines from a huge file."""
    for i in range(n):
        yield f"line {i}: some content"
 
# List: builds ALL lines in memory
big_list = list(read_lines_lazy(100))
# Generator: streams, one line at a time
big_gen = read_lines_lazy(100)
 
# Pipe-style processing — the reason generators shine
pipeline = (
    line.upper()
    for line in big_gen
    if "5" in line
)
first_five = list(islice(pipeline, 5))
print(first_five)
 
# Consume the pipeline in constant memory
total_chars = sum(len(line) for line in read_lines_lazy(1_000_000))
print(f"processed 1M lines in constant memory; total chars = {total_chars}")
 
# =========================
# Part 5 · itertools that replace loops
# =========================
print("\n--- Part 5 ---")
 
# chain — flatten
flat = list(chain([1, 2, 3], [4, 5], [6]))
print("chain:", flat)
 
# product — cartesian
combos = list(product("AB", [1, 2]))
print("product:", combos)
 
# groupby — cluster CONSECUTIVE keys
data = [("a", 1), ("a", 2), ("b", 3), ("a", 4)]
# Note: groupby only groups consecutive; sort first for global grouping.
for key, group in groupby(sorted(data, key=itemgetter(0)), key=itemgetter(0)):
    print(f"  {key}: {[v for _, v in group]}")
 
# =========================
# Part 6 · When comprehensions go too far
# =========================
print("\n--- Part 6 ---")
 
items = [{"name": "a", "tags": ["x", "y"]}, {"name": "b", "tags": ["y", "z"]}]
 
# BAD — please don't
bad = [t for i in items for t in i["tags"] if t != "z" if len(t) == 1]
 
# GOOD — same output, readable
good = []
for item in items:
    for tag in item["tags"]:
        if tag != "z" and len(tag) == 1:
            good.append(tag)
 
print("bad :", bad)
print("good:", good)
print("^^ rule of thumb: > 1 filter or > 1 nesting → promote to a for-loop")