Python Decorators Explained: From Simple Wrappers to Production Patterns

import functools

def timer(fn):
    @functools.wraps(fn)  # Preserves __name__, __doc__
    def wrapper(*args, **kwargs):
        import time
        start = time.perf_counter()
        result = fn(*args, **kwargs)
        ms = (time.perf_counter() - start) * 1000
        print(f"{fn.__name__} took {ms:.1f}ms")
        return result
    return wrapper

@timer  # Same as: greet = timer(greet)
def greet(name):
    return f"Hello, {name}"

greet("Alice")  # greet took 0.01ms

import functools, time

def retry(max_attempts=3, delay=1.0, exceptions=(Exception,)):
    def decorator(fn):
        @functools.wraps(fn)
        def wrapper(*args, **kwargs):
            last_exc = None
            for attempt in range(1, max_attempts + 1):
                try:
                    return fn(*args, **kwargs)
                except exceptions as e:
                    last_exc = e
                    if attempt < max_attempts:
                        time.sleep(delay * attempt)
            raise last_exc
        return wrapper
    return decorator

@retry(max_attempts=5, delay=0.5, exceptions=(ConnectionError,))
def call_api(url: str) -> dict:
    pass

# Stacking (applied bottom-up):
@timer           # Second (outer)
@retry(3, 1.0)  # First (inner)
def fetch_data(url):
    pass

from functools import lru_cache, cache

@cache  # Python 3.9+ unbounded
def fibonacci(n):
    if n < 2: return n
    return fibonacci(n-1) + fibonacci(n-2)

@lru_cache(maxsize=128)  # Bounded LRU
def expensive_query(user_id: int, page: int):
    pass  # Result cached per (user_id, page) combo

# Class-based decorator: singleton
def singleton(cls):
    instances = {}
    @functools.wraps(cls)
    def get(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get

@singleton
class DatabasePool:
    def __init__(self): self.connections = []