Wat zijn decorators en hoe schrijf je er een?

Question

Accepted Answer

Een **decorator** is een functie die **een andere functie omwikkelt** om gedrag toe te voegen, zonder de originele code te wijzigen. Het wordt toegepast met de `@decorator` syntaxis boven een functie — een schone manier om cross-cutting concerns zoals logging, timing, caching of access control toe te voegen.

## Hoe decorators werken

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

De `@my_decorator` syntaxis is syntaxsuiker voor `greet = my_decorator(greet)` — het vervangt `greet` met de `wrapper`, die extra code rond de originele aanroep uitvoert. De `*args, **kwargs` zorgt ervoor dat de wrapper voor elke functiesignatuur werkt.

## Een praktisch voorbeeld: 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)` is belangrijk — zonder het verliest de omwikkelde functie zijn originele naam en docstring.

## Decorators met argumenten

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

Een geparametriseerde decorator heeft een extra laag nodig (een functie die een decorator retourneert).

## Veelgebruikte ingebouwde / bibliotheek decorators

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

## Waarom het belangrijk is

Decorators zijn een krachtig, duidelijk-Pythonisch feature voor **herbruikbaar gedrag toevoegen** (logging, timing, caching, authenticatie, validatie, routing) aan functies op een schone en declaratieve manier — cross-cutting concerns scheiden van kernlogica.

Ze zijn overal in echte Python: webframeworks (`@app.route`), caching (`@lru_cache`), klassen (`@property`), en testen.

Begrijpen hoe je ze schrijft (een wrapper functie, `*args/**kwargs`, `functools.wraps`) en de geparametriseerde vorm stelt je in staat om zowel de decorators van het ecosysteem correct te gebruiken als je eigen herbruikbare abstracties te bouwen.