Ce sunt decoratorii și cum scrii un decorador?

Question

Accepted Answer

Un **decorador** este o funcție care **înfășoară o altă funcție** pentru a adăuga comportament fără a modifica codul original. Este aplicat cu sintaxa `@decorator` deasupra unei funcții — o modalitate curată de a adăuga probleme transversale (cross-cutting concerns) cum ar fi logging, timing, caching sau control de acces.

## Cum funcționează decoratorii

```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
```

Sintaxa `@my_decorator` este sucru pentru `greet = my_decorator(greet)` — înlocuiește `greet` cu `wrapper`, care execută cod suplimentar în jurul apelului original. `*args, **kwargs` face ca wrapper-ul să funcționeze pentru orice semnatură de funcție.

## Un exemplu practic: timing

```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)` este important — fără el, funcția înfășurată și pierde numele original și docstring-ul.

## Decoratori cu argumente

```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
```

Un decorador parametrizat are nevoie de un strat suplimentar (o funcție care întoarce un decorador).

## Decoratori comuni incorporați / din bibliotecă

```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
```

## De ce conteaza

Decoratoriisunt o funcționalitate puternică, distinctiv pythonică pentru **adăugarea comportamentului reutilizabil** (logging, timing, caching, autentificare, validare, rutare) la funcții în mod curat și declarativ — separând problemele transversale de logica principală.

Sunt peste tot în Python real: framework-uri web (`@app.route`), caching (`@lru_cache`), clase (`@property`) și testare.

Înțelegerea modului de a le scrie (o funcție wrapper, `*args/**kwargs`, `functools.wraps`) și forma parametrizată vă permite să utilizați corect decoratorii ecosistemului și să construiți propriile abstracții reutilizabile.