Co jsou dekorátory a jak je napsat?

Question

Accepted Answer

**Dekorátor** je funkce, která **obaluje jinou funkci** a přidává chování, aniž by upravila původní kód. Aplikuje se pomocí syntaxe `@decorator` nad funkcí — čistý způsob, jak přidat cross-cutting concerns, jako je logování, měření času, cachování nebo kontrolu přístupu.

## Jak dekorátory fungují

```python
def my_decorator(func):
    def wrapper(*args, **kwargs):       # wraps the original function
        print("before")
        result = func(*args, **kwargs)  # call the original
        print("after")
        return result
    return wrapper                       # return the wrapped version

@my_decorator
def greet(name):
    print(f"Hello {name}")

greet("Ann")
# Output: before / Hello Ann / after
```

Syntaxe `@my_decorator` je syntactic sugar pro `greet = my_decorator(greet)` — nahradí `greet` pomocí `wrapper`, který spustí dodatečný kód kolem původního volání. `*args, **kwargs` umožňuje wrapper pracovat s jakýmkoli podpisem funkce.

## Praktický příklad: měření času

```python
import time, functools

def timed(func):
    @functools.wraps(func)        # preserves func's name/docstring (important!)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.perf_counter() - start:.3f}s")
        return result
    return wrapper

@timed
def slow_task():
    time.sleep(1)
```

`@functools.wraps(func)` je důležité — bez toho by obalená funkce ztratila svůj původní název a docstring.

## Dekorátory s argumenty

```python
def repeat(times):               # outer takes the decorator's argument
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(times=3)
def hello(): print("hi")  # prints "hi" three times
```

Parametrizovaný dekorátor potřebuje dodatečnou vrstvu (funkci, která vrací dekorátor).

## Běžné vestavěné / knihovnické dekorátory

```text
@property            → turn a method into a computed attribute
@staticmethod / @classmethod → method types
@functools.lru_cache → memoize results
@app.route("/")      → web framework routing (Flask)
@pytest.fixture      → test fixtures
```

## Proč je to důležité

Dekorátory jsou **mocná, charakteristicky pythonská funkce** pro **přidávání opakovaně použitelného chování** (logování, měření času, cachování, ověřování, ověřování, směrování) do funkcí čistě a deklarativně — oddělení cross-cutting concerns od základní logiky.

Jsou všude v reálném Pythonu: webové frameworky (`@app.route`), cachování (`@lru_cache`), třídy (`@property`) a testování.

Porozumění tomu, jak je psát (funkce wrapper, `*args/**kwargs`, `functools.wraps`) a parametrizovaná forma vám umožní správně používat dekorátory ekosystému a vytvářet vlastní opakovaně použitelné abstrakce.