Functions — arguments, scope, closures

def request(url, /, method="GET", *headers, timeout=30, **params):
    ...
 
# url is positional-only
# method is positional-or-keyword with a default
# *headers gathers any extra positional args into a tuple
# timeout is keyword-only (because it comes after *headers)
# **params gathers any extra keyword args into a dict

"""s007_functions.py — the full menu of Python function features."""
from __future__ import annotations
from functools import wraps, partial, lru_cache
import time
from typing import Callable, Any
 
# =========================
# Part 1 · Signature grammar
# =========================
print("--- Part 1 ---")
 
def request(url, /, method="GET", *headers, timeout=30, **params):
    return f"{method} {url} timeout={timeout} headers={headers} params={params}"
 
print(request("https://x", "POST", "H1", "H2", timeout=5, page=2, sort="new"))
# Try to call `request(url="x")` — it fails: url is positional-only.
 
# =========================
# Part 2 · Default arg trap (revisited from S005)
# =========================
print("\n--- Part 2 ---")
 
def bad(item, bin=[]):
    bin.append(item)
    return bin
 
def good(item, bin=None):
    bin = [] if bin is None else bin
    bin.append(item)
    return bin
 
print(bad("a"), bad("b"))     # shared default — PREDICT
print(good("a"), good("b"))   # fresh each call
 
# =========================
# Part 3 · Scope (LEGB) and nonlocal / global
# =========================
print("\n--- Part 3 ---")
 
x = "global"
 
def outer():
    x = "enclosing"
    def inner_read():
        # reads x from Enclosing (LEGB)
        return x
    def inner_write_local():
        # this creates a new LOCAL x — doesn't touch enclosing
        x = "local"
        return x
    def inner_write_nonlocal():
        nonlocal x
        x = "changed by nonlocal"
        return x
    print("read:", inner_read())
    print("write local:", inner_write_local(), "outer x:", x)
    print("write nonlocal:", inner_write_nonlocal(), "outer x:", x)
 
outer()
print("module x:", x)
 
# =========================
# Part 4 · The late-binding closure bug
# =========================
print("\n--- Part 4 ---")
 
# Bug — all three lambdas capture the SAME i
funcs = [lambda: i for i in range(3)]
print("bug:", [f() for f in funcs])
 
# Fix 1 — default argument snapshot
funcs = [lambda i=i: i for i in range(3)]
print("fix1:", [f() for f in funcs])
 
# Fix 2 — factory function
def make(i):
    def f():
        return i
    return f
funcs = [make(i) for i in range(3)]
print("fix2:", [f() for f in funcs])
 
# =========================
# Part 5 · Closures with state
# =========================
print("\n--- Part 5 ---")
 
def make_counter(start: int = 0) -> Callable[[], int]:
    count = start
    def inc() -> int:
        nonlocal count
        count += 1
        return count
    return inc
 
c1 = make_counter()
c2 = make_counter(100)
print(c1(), c1(), c1())
print(c2(), c2())
 
# =========================
# Part 6 · Decorator from scratch
# =========================
print("\n--- Part 6 ---")
 
def timed(func: Callable) -> Callable:
    @wraps(func)                # preserves __name__, __doc__
    def wrapper(*args: Any, **kwargs: Any) -> Any:
        t0 = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = (time.perf_counter() - t0) * 1000
        print(f"  {func.__name__} took {elapsed:.2f} ms")
        return result
    return wrapper
 
@timed
def slow_add(a: int, b: int) -> int:
    """Add two numbers slowly, for demo."""
    time.sleep(0.05)
    return a + b
 
print(slow_add(2, 3))
print("still named correctly:", slow_add.__name__)   # 'slow_add' thanks to @wraps
 
# Parameterised decorator
def repeat(n: int) -> Callable:
    def decorator(func: Callable) -> Callable:
        @wraps(func)
        def wrapper(*args: Any, **kwargs: Any) -> list:
            return [func(*args, **kwargs) for _ in range(n)]
        return wrapper
    return decorator
 
@repeat(3)
def greet(name: str) -> str:
    return f"hi {name}"
 
print(greet("ada"))
 
# =========================
# Part 7 · Higher-order plumbing
# =========================
print("\n--- Part 7 ---")
 
# functools.partial
add = lambda a, b: a + b
add5 = partial(add, 5)
print(add5(10))
 
# functools.lru_cache — a real-world decorator
@lru_cache(maxsize=128)
def fib(n: int) -> int:
    return n if n < 2 else fib(n - 1) + fib(n - 2)
 
print([fib(i) for i in range(10)])
print("cache stats:", fib.cache_info())
 
# =========================
# Part 8 · Callable classes
# =========================
print("\n--- Part 8 ---")
 
class Multiplier:
    """A callable that carries state."""
    def __init__(self, factor: int) -> None:
        self.factor = factor
    def __call__(self, x: int) -> int:
        return x * self.factor
 
times3 = Multiplier(3)
print(times3(10), times3(4))
print("is it callable?", callable(times3))