Comprehensions, Lambdas & the Iterator Protocol¶

sales = [
    {"product": "Widget", "revenue": 120, "region": "APAC"},
    {"product": "Gadget", "revenue": 450, "region": "EMEA"},
    {"product": "Doohickey", "revenue": 90, "region": "APAC"},
    {"product": "Thingamajig", "revenue": 310, "region": "EMEA"},
]

# List comprehension: transform
revenues = [row["revenue"] for row in sales]
print(revenues)   # [120, 450, 90, 310]

# Filter: only high-value
big_deals = [row["product"] for row in sales if row["revenue"] > 200]
print(big_deals)   # ['Gadget', 'Thingamajig']

# Dict comprehension: product → revenue map
rev_map = {row["product"]: row["revenue"] for row in sales}
print(rev_map)     # {'Widget': 120, 'Gadget': 450, ...}

# Set comprehension: unique regions
regions = {row["region"] for row in sales}
print(regions)     # {'APAC', 'EMEA'} (order varies)

# Generator expression (lazy – parens, not brackets)
total = sum(row["revenue"] for row in sales)
print(total)       # 970

# Flatten a 2-D matrix
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [cell for row in matrix for cell in row]
print(flat)   # [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Transpose (rows become columns)
transposed = [[row[i] for row in matrix] for i in range(3)]
print(transposed)   # [[1, 4, 7], [2, 5, 8], [3, 6, 9]]

# Cartesian product (pairs of sizes and colours)
sizes   = ["S", "M", "L"]
colours = ["red", "blue"]
skus = [f"{s}-{c}" for s in sizes for c in colours]
print(skus)
# ['S-red', 'S-blue', 'M-red', 'M-blue', 'L-red', 'L-blue']

import re

log_lines = [
    "2024-01-15 ERROR disk full",
    "2024-01-15 INFO  backup started",
    "2024-01-15 ERROR connection timeout",
    "2024-01-15 DEBUG heartbeat",
]

# Without walrus: regex match twice (once to filter, once to extract)
errors_bad = [re.search(r"ERROR (.+)", line).group(1)
              for line in log_lines
              if re.search(r"ERROR (.+)", line)]   # double work

# With walrus: compute once, reuse in same expression
errors_good = [m.group(1)
               for line in log_lines
               if (m := re.search(r"ERROR (.+)", line))]

print(errors_good)   # ['disk full', 'connection timeout']

# Walrus also works for side-effectful computations
import random
random.seed(42)
results = [y for x in range(5) if (y := random.randint(1, 10)) > 5]
print(results)   # [7, 10, 8] (values already computed, not recomputed)

# What Python's for-loop actually does:
lst = [10, 20, 30]
it = iter(lst)              # calls lst.__iter__()
print(next(it))             # 10  (calls it.__next__())
print(next(it))             # 20
print(next(it))             # 30
# print(next(it))           # → StopIteration

# Writing a custom iterator
class CountUp:
    """Yields integers from start up to stop (inclusive)."""
    def __init__(self, start, stop):
        self.current = start
        self.stop    = stop

    def __iter__(self):
        return self       # iterator is its own iterable

    def __next__(self):
        if self.current > self.stop:
            raise StopIteration
        value = self.current
        self.current += 1
        return value

for n in CountUp(1, 5):
    print(n, end=" ")   # 1 2 3 4 5

import itertools

# product – Cartesian product (like nested for-loops)
for a, b in itertools.product("AB", [1, 2]):
    print(f"({a},{b})", end=" ")   # (A,1) (A,2) (B,1) (B,2)
print()

# combinations / permutations
print(list(itertools.combinations("ABCD", 2)))
# [('A','B'),('A','C'),('A','D'),('B','C'),('B','D'),('C','D')]

# groupby – consecutive groups (data must be pre-sorted by key)
events = [("APAC","login"),("APAC","purchase"),("EMEA","login"),("EMEA","view")]
for region, group in itertools.groupby(events, key=lambda e: e[0]):
    actions = [g[1] for g in group]
    print(f"{region}: {actions}")
# APAC: ['login', 'purchase']
# EMEA: ['login', 'view']

# takewhile / dropwhile
nums = [2, 4, 6, 7, 8, 10]
print(list(itertools.takewhile(lambda n: n % 2 == 0, nums)))  # [2, 4, 6]
print(list(itertools.dropwhile(lambda n: n % 2 == 0, nums)))  # [7, 8, 10]

# chain – concatenate iterables without building a list
a = range(3)
b = range(5, 8)
print(list(itertools.chain(a, b)))   # [0, 1, 2, 5, 6, 7]

# islice – lazy slicing of any iterator
inf_squares = (n*n for n in itertools.count(1))
print(list(itertools.islice(inf_squares, 6)))   # [1, 4, 9, 16, 25, 36]

from functools import reduce

# Good use: short, single-expression key function
records = [("Alice", 32), ("Bob", 25), ("Carol", 28)]
records.sort(key=lambda r: r[1])    # sort by age
print(records)   # [('Bob', 25), ('Carol', 28), ('Alice', 32)]

# Good use: inline with map/filter/reduce
prices = [9.99, 24.50, 3.75, 149.00]
discounted = list(map(lambda p: round(p * 0.9, 2), prices))
print(discounted)   # [8.99, 22.05, 3.38, 134.1]

total = reduce(lambda acc, p: acc + p, prices, 0)
print(f"Total: ${total:.2f}")   # Total: $187.24

# ❌ Anti-pattern: assigning lambda to a name
# bad:  double = lambda x: x * 2
# good: def double(x): return x * 2
# Named lambdas lose traceback clarity and can't have docstrings.