Dekoratoren: Funktionen, die Funktionen modifizieren

Ein Dekorator (decorator) ist eine Funktion, die eine andere Funktion entgegennimmt und eine "dekorierte" Version davon zurückgibt. Es ist eine leistungsstarke Methode, um Verhalten (Logging, Zeitmessung, Caching, Retry, Validierung) hinzuzufügen, ohne den Rumpf der ursprünglichen Funktion zu verändern.

Funktionen als Werte

In Python sind Funktionen Objekte: Du kannst sie übergeben, zurückgeben und zuweisen.

def saluta():
    print("ciao")

f = saluta   # NIENTE parentesi: assegno la funzione
f()          # 'ciao'

Ein minimaler Dekorator

def log(func):
    def wrapper(*args, **kwargs):
        print(f"chiamo {func.__name__}")
        risultato = func(*args, **kwargs)
        print(f"ho finito {func.__name__}")
        return risultato
    return wrapper

def somma(a, b):
    return a + b

somma = log(somma)   # ora somma è "wrapper"
somma(2, 3)
# chiamo somma
# ho finito somma
# 5

Die @decorator-Syntax

Die Zuweisung somma = log(somma) wird mit @ eleganter geschrieben:

@log
def somma(a, b):
    return a + b

Es ist genau dasselbe. @log über der Definition entspricht: "Sobald diese Funktion definiert ist, ersetze sie durch log(funktion)".

*args, **kwargs: Jede Signatur akzeptieren

def wrapper(*args, **kwargs):
    return func(*args, **kwargs)

*args sammelt Positionsargumente, **kwargs Keyword-Argumente. Sie ermöglichen es dir, Wrapper zu schreiben, die mit jeder Funktion funktionieren.

functools.wraps: Metadaten beibehalten

Ohne wraps verliert die dekorierte Funktion __name__, __doc__ und Type-Hints:

from functools import wraps

def log(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        ...
        return func(*args, **kwargs)
    return wrapper

Beispiel: @timeit

from functools import wraps
import time

def timeit(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        t0 = time.perf_counter()
        risultato = func(*args, **kwargs)
        dt = time.perf_counter() - t0
        print(f"{func.__name__} ha impiegato {dt*1000:.2f} ms")
        return risultato
    return wrapper

@timeit
def somma_grande():
    return sum(range(10**6))

somma_grande()

Dekoratoren aus der stdlib

from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    if n < 2: return n
    return fib(n - 1) + fib(n - 2)

fib(100)  # istantaneo grazie alla cache

• @lru_cache – speichert die Ergebnisse einer reinen Funktion (Memoisation).
• @property – macht eine Methode als Attribut zugänglich (siehe OOP-Modul).
• @staticmethod, @classmethod – ändern die Art und Weise, wie self übergeben wird.

Dekoratoren mit Argumenten

Dekoratoren können auch Argumente entgegennehmen. Um dies zu implementieren, musst du drei Ebenen verschachtelter Funktionen schreiben: Die äußerste Funktion erhält die Argumente des Dekorators, die mittlere Funktion erhält die dekorierte Funktion und die innerste Funktion (wrapper) erhält die tatsächlichen Argumente, die der dekorierten Funktion beim Aufruf übergeben werden.

Probiere es aus

Wiederholungsübung

Zusätzliche Herausforderung