Weeks 1–3 — Type Hints & Dataclasses · Decorators & Context Managers · Iterators & Generators

from typing import Optional, Union

def greet(name: str, times: int = 1) -> str:
    return (name + "\n") * times

def find_user(user_id: int) -> Optional[dict]:
    db = {1: {"name": "Alice"}}
    return db.get(user_id)

# Union (Python 3.10+: use | directly)
def stringify(value: Union[int, float, str]) -> str:
    return str(value)

from typing import TypeVar, List

T = TypeVar("T")

def first(lst: List[T]) -> Optional[T]:
    return lst[0] if lst else None

print(first([1, 2, 3]))       # 1  — inferred as int
print(first(["a", "b"]))     # "a" — inferred as str

from dataclasses import dataclass, field
from typing import List

@dataclass(frozen=True)  # immutable
class Point:
    x: float
    y: float

@dataclass
class Team:
    name: str
    members: List[str] = field(default_factory=list)

    def add(self, member: str) -> None:
        self.members.append(member)

t = Team("Alpha")
t.add("Alice")
t.add("Bob")
print(t)  # Team(name='Alpha', members=['Alice', 'Bob'])

from typing import Protocol, runtime_checkable

@runtime_checkable
class Drawable(Protocol):
    def draw(self) -> str: ...

class Circle:
    def draw(self) -> str: return "O"

class Square:
    def draw(self) -> str: return "[]"

def render(shape: Drawable) -> None:
    print(shape.draw())

render(Circle())   # O
render(Square())   # []

import functools, time

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.4f}s")
        return result
    return wrapper

@timer
def slow_sum(n):
    return sum(range(n))

print(slow_sum(1_000_000))

import functools

def retry(max_attempts=3, exceptions=(Exception,)):
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(1, max_attempts + 1):
                try:
                    return func(*args, **kwargs)
                except exceptions as e:
                    if attempt == max_attempts:
                        raise
                    print(f"  Attempt {attempt} failed: {e}. Retrying...")
        return wrapper
    return decorator

@retry(max_attempts=3, exceptions=(ValueError,))
def risky():
    import random
    if random.random() < 0.7:
        raise ValueError("unlucky")
    return "success"

from contextlib import contextmanager
import time

@contextmanager
def timer_ctx(label=""):
    start = time.perf_counter()
    try:
        yield
    finally:
        elapsed = time.perf_counter() - start
        print(f"{label} {elapsed:.4f}s")

with timer_ctx("matrix multiply:"):
    result = sum(i*j for i in range(1000) for j in range(100))

class Counter:
    def __init__(self, start, stop):
        self.current = start
        self.stop = stop

    def __iter__(self):
        return self

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

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

def range_gen(start, stop, step=1):
    current = start
    while current < stop:
        yield current
        current += step

# Same as above but lazy — no list created
for n in range_gen(0, 10, 2):
    print(n, end=' ')   # 0 2 4 6 8

# yield from
def chain(*iterables):
    for it in iterables:
        yield from it

print(list(chain([1,2], [3,4], [5])))  # [1,2,3,4,5]

def accumulator():
    total = 0
    while True:
        value = yield total
        if value is None:
            break
        total += value

acc = accumulator()
next(acc)           # prime the generator
print(acc.send(10)) # 10
print(acc.send(20)) # 30
print(acc.send(5))  # 35