Advanced Python

nums = [3, -1, 4, -1, 5, -9, 2]

# The loop…
squares = []
for n in nums:
    if n > 0:
        squares.append(n * n)
# …and the comprehension
squares2 = [n * n for n in nums if n > 0]
print(squares == squares2, squares2)

# dict and set comprehensions
words = ["apple", "fig", "banana"]
print({w: len(w) for w in words})
print({len(w) for w in words})

# conditional expression INSIDE (not a filter — every item is kept)
print(["even" if n % 2 == 0 else "odd" for n in range(4)])

# nested: flatten a grid (read left to right, like nested for loops)
grid = [[1, 2], [3, 4], [5]]
print([x for row in grid for x in row])

# a generator expression: no brackets, no list built — feed it straight to sum()
print(sum(n * n for n in range(1_000_000)))

it = iter([10, 20, 30])
print(next(it), next(it), next(it))
try:
    next(it)
except StopIteration:
    print("exhausted — a for loop catches this for you")

# An iterator is consumed once. A list can be iterated many times.
z = zip("ab", [1, 2])
print(list(z), list(z))       # second time: empty!

# Your own iterator: countdown
class Countdown:
    def __init__(self, start): self.n = start
    def __iter__(self): return self
    def __next__(self):
        if self.n <= 0:
            raise StopIteration
        self.n -= 1
        return self.n + 1

print(list(Countdown(3)))

# range is lazy: 10 billion numbers, no memory
big = range(10_000_000_000)
print(len(big), 9_999_999_999 in big)

# itertools: the iterator toolbox
import itertools
print(list(itertools.islice(itertools.count(5), 3)))     # 5, 6, 7 from an infinite counter
print(list(itertools.chain([1, 2], (3,), "ab")))

def read_records(lines):
    """Yield parsed records one at a time — the file is never fully in memory."""
    for line in lines:
        line = line.strip()
        if not line or line.startswith("#"):
            continue
        name, score = line.split(",")
        yield name, int(score)

raw = ["# name,score", "ada,98", "", "linus,87", "grace,91"]
for name, score in read_records(raw):
    print(name, score)

# Pipelines of generators: each stage pulls from the previous, one item at a time
scores = (score for _, score in read_records(raw))
high = (s for s in scores if s > 90)
print(list(high))

# Infinite generator, safely consumed with a limit
def fib():
    a, b = 0, 1
    while True:
        yield a
        a, b = b, a + b
import itertools
print(list(itertools.islice(fib(), 10)))

# yield from: delegate to another iterable
def flatten(nested):
    for item in nested:
        if isinstance(item, list):
            yield from flatten(item)
        else:
            yield item
print(list(flatten([1, [2, [3, 4]], 5])))

def make_multiplier(factor):
    def multiply(x):
        return x * factor        # factor is captured from the enclosing scope
    return multiply

double = make_multiplier(2)
triple = make_multiplier(3)
print(double(10), triple(10))
print(double.__closure__[0].cell_contents)   # the captured value, if you are curious

# A counter that keeps state — needs nonlocal to REBIND the captured name
def make_counter():
    count = 0
    def bump():
        nonlocal count
        count += 1
        return count
    return bump

c = make_counter()
print(c(), c(), c())

# The late-binding trap: all three lambdas share ONE i, read at call time
fns = [lambda: i for i in range(3)]
print([f() for f in fns])                      # [2, 2, 2] — not [0, 1, 2]
fns = [lambda i=i: i for i in range(3)]       # bind now with a default
print([f() for f in fns])

import functools, time

def timed(func):
    @functools.wraps(func)            # keeps func's name and docstring on the wrapper
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        ms = (time.perf_counter() - start) * 1000
        print(f"{func.__name__} took {ms:.1f} ms" if ms > 50 else f"{func.__name__} was fast")
        return result
    return wrapper

@timed
def total(n):
    """Sum 0..n-1."""
    return sum(range(n))

print(total(1_000_000))
print(total.__name__, "|", total.__doc__)   # wraps preserved these

# Decorators with arguments: a function that RETURNS a decorator
def retry(times):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, times + 1):
                try:
                    return func(*args, **kwargs)
                except ValueError as e:
                    print(f"attempt {attempt} failed: {e}")
            raise RuntimeError("gave up")
        return wrapper
    return decorator

calls = 0
@retry(times=3)
def flaky():
    global calls
    calls += 1
    if calls < 3:
        raise ValueError("not yet")
    return "ok on call " + str(calls)

print(flaky())

# The one you will use most: memoisation, built in
@functools.lru_cache(maxsize=None)
def fib(n):
    return n if n < 2 else fib(n - 1) + fib(n - 2)
print(fib(80))

from dataclasses import dataclass
from typing import Optional, Protocol, TypedDict, Iterable

def mean(values: Iterable[float]) -> float:
    values = list(values)
    return sum(values) / len(values) if values else 0.0

def find_user(users: dict[int, str], uid: int) -> str | None:   # 3.10+ union syntax
    return users.get(uid)

class Movie(TypedDict):          # a dict with known keys
    title: str
    year: int

class HasArea(Protocol):         # duck typing, but checkable
    def area(self) -> float: ...

def describe(shape: HasArea) -> str:
    return f"area {shape.area():.1f}"

@dataclass
class Sq:
    s: float
    def area(self) -> float: return self.s ** 2

print(mean([1, 2, 3.5]))
print(find_user({1: "ada"}, 2))
m: Movie = {"title": "Alien", "year": 1979}
print(m["title"], describe(Sq(3)))

# Hints are not enforced — this runs. A type checker would flag it.
print(mean(["a", "b"]) if False else "mypy would catch mean(['a'])")
print(mean.__annotations__)