¿Qué son los decoradores y cómo se escribe uno?

Question

Accepted Answer

Un **decorador** es una función que **envuelve a otra función** para añadir comportamiento, sin modificar el código de la original. Se aplica con la sintaxis `@decorator` encima de una función — una forma limpia de añadir aspectos transversales como logging, medición de tiempo, caching o control de acceso.

## Cómo funcionan los decoradores

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

La sintaxis `@my_decorator` es azúcar sintáctico para `greet = my_decorator(greet)` — reemplaza `greet` por el `wrapper`, que ejecuta código adicional alrededor de la llamada original. El `*args, **kwargs` hace que el wrapper funcione con cualquier firma de función.

## Un ejemplo práctico: medición de tiempo

```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)` es importante — sin él, la función envuelta pierde su nombre original y su docstring.

## Decoradores con argumentos

```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 parametrizado necesita una capa adicional (una función que devuelve un decorador).

## Decoradores comunes de built-in / bibliotecas

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

## Por qué es importante

Los decoradores son una característica potente y claramente pythónica para **añadir comportamiento reutilizable** (logging, medición de tiempo, caching, autenticación, validación, enrutamiento) a funciones de forma limpia y declarativa — separando los aspectos transversales de la lógica central.

Están en todas partes en el Python real: frameworks web (`@app.route`), caching (`@lru_cache`), clases (`@property`) y testing.

Entender cómo escribirlos (una función wrapper, `*args/**kwargs`, `functools.wraps`) y la forma parametrizada te permite tanto usar correctamente los decoradores del ecosistema como construir tus propias abstracciones reutilizables.