Was sind Dekoratoren und wie schreibt man einen?

Question

Accepted Answer

Ein **Dekorator** ist eine Funktion, die **eine andere Funktion umhüllt**, um ein Verhalten hinzuzufügen, ohne den ursprünglichen Code zu ändern. Er wird mit der `@decorator`-Syntax über einer Funktion angewendet — eine saubere Möglichkeit, Cross-Cutting Concerns wie Logging, Timing, Caching oder Zugriffskontrolle hinzuzufügen.

## Wie Dekoratoren funktionieren

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

Die `@my_decorator`-Syntax ist syntactic sugar für `greet = my_decorator(greet)` — sie ersetzt `greet` durch den `wrapper`, der zusätzlichen Code um den ursprünglichen Aufruf herum ausführt. Das `*args, **kwargs` ermöglicht dem wrapper, mit jeder Funktionssignatur zu funktionieren.

## Ein praktisches Beispiel: 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)` ist wichtig — ohne es verliert die umhüllte Funktion ihren ursprünglichen Namen und docstring.

## Dekoratoren mit 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
```

Ein parametrisierter Dekorator benötigt eine zusätzliche Ebene (eine Funktion, die einen Dekorator zurückgibt).

## Häufige Built-in- / Bibliotheks-Dekoratoren

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

## Warum es wichtig ist

Dekoratoren sind eine mächtige, charakteristisch pythonische Funktion zum **Hinzufügen wiederverwendbaren Verhaltens** (Logging, Timing, Caching, Authentifizierung, Validierung, Routing) zu Funktionen sauber und deklarativ — Trennung von Cross-Cutting Concerns von der Kernlogik.

Sie sind überall in echtem Python: Web-Frameworks (`@app.route`), Caching (`@lru_cache`), Klassen (`@property`) und Testing.

Das Verständnis, wie man sie schreibt (eine wrapper-Funktion, `*args/**kwargs`, `functools.wraps`) und die parametrisierte Form ermöglicht es dir, die Dekoratoren des Ökosystems korrekt zu nutzen und deine eigenen wiederverwendbaren Abstraktionen zu erstellen.