Python Decorators einfach erklärt: So funktionieren sie

Du sitzt im Betrieb vor einem Python-Projekt deines Kollegen und siehst plötzlich sowas hier:

@app.route("/startseite")
def zeige_startseite():
    return "Willkommen!"

Was macht dieses `@` da drüber? Ob in der Ausbildung, im Studium oder im ersten Job - irgendwann läuft dir dieses Zeichen über den Weg. Die gute Nachricht: Dahinter steckt ein Konzept, das sich in fünf Minuten verstehen lässt. Das Zauberwort heißt Python Decorators.

Was sind Python Decorators?

Ein Decorator ist eine Funktion, die eine andere Funktion als Argument bekommt und eine neue Funktion zurückgibt. Dabei erweitert der Decorator das Verhalten der ursprünglichen Funktion - ohne deren Code zu verändern.

Stell dir vor, du schenkst jemandem ein Buch. Der Inhalt des Buchs ändert sich nicht, aber du packst es in Geschenkpapier, klebst einen Zettel dran und gibst es persönlich ab. Genau das macht ein Decorator: Er legt eine Schicht um deine Funktion - zum Beispiel Logging, Zeitmessung oder Zugriffsprüfung - und lässt den Kern unangetastet.

Merke: Ein Decorator verpackt eine Funktion, ohne ihren Code zu ändern. Die `@`-Syntax ist nur die Abkürzung dafür.

Die offizielle Definition findest du im Python-Glossar.

Warum sind Funktionen in Python Objekte?

In Python sind Funktionen Objekte erster Klasse (englisch: *first-class functions*) - und genau das macht Decorators überhaupt erst möglich. Du kannst sie wie normale Werte behandeln: einer Variablen zuweisen, weitergeben und sogar als Rückgabewert einer anderen Funktion nutzen.

def begruessung():
    print("Hallo!")


# Funktion einer Variablen zuweisen (ohne Klammern!)
nachricht = begruessung

# Aufruf ueber die Variable
nachricht()  # Ausgabe: Hallo!

Merke: `begruessung` (ohne Klammern) übergibt die Funktion selbst. `begruessung()` ruft sie auf und liefert ihren Rückgabewert.

Wie funktioniert ein Decorator Schritt für Schritt?

Ein Decorator ist im Kern eine Funktion, die innen eine weitere Funktion definiert und diese zurückgibt. Diese innere Funktion nennt man üblicherweise `wrapper` (englisch für „Verpackung"). Schauen wir uns das ohne `@` und ohne jede Magie an:

def log_dekorator(funktion):
    def wrapper():
        print("Vor dem Aufruf")
        funktion()
        print("Nach dem Aufruf")

    return wrapper


def begruessung():
    print("Hallo!")


# Decorator von Hand anwenden
begruessung = log_dekorator(begruessung)
begruessung()

Die Ausgabe:

Vor dem Aufruf
Hallo!
Nach dem Aufruf

Was passiert hier genau? `log_dekorator` nimmt `begruessung` entgegen und baut daraus `wrapper`. Dieser `wrapper` ruft die Original-Funktion auf - packt aber seine eigenen Anweisungen davor und dahinter. Zurückbekommen wir die verpackte Version, die wir wieder unter dem alten Namen `begruessung` speichern.

Das funktioniert nur, weil Funktionen Objekte sind - genau das Wissen aus dem Abschnitt davor. Auch Lambda-Funktionen kannst du so weiterreichen.

Was macht das @-Zeichen?

Das `@`-Zeichen ist reine Syntaxvereinfachung (englisch: *syntactic sugar*). Diese zwei Varianten sind exakt identisch:

# Variante 1: von Hand
def begruessung():
    print("Hallo!")


begruessung = log_dekorator(begruessung)


# Variante 2: mit @-Zeichen (identisches Ergebnis)
@log_dekorator
def begruessung():
    print("Hallo!")

Mehr steckt nicht dahinter. Das `@` nimmt dir nur die Zuweisung `funktion = decorator(funktion)` ab. Deshalb liest sich Code mit Decorators so elegant: Die Zeile über der Funktion sagt dir sofort, welche Zusatzfunktionalität dort mit dabei ist.

Du kannst Decorators auch stapeln:

Merke: Gestapelte Decorators werden von unten nach oben angewendet - der unterste läuft zuerst.

@timer
@log_dekorator
def begruessung():
    print("Hallo!")

Praxisbeispiel: Ein Timer-Decorator

Ein Timer-Decorator misst, wie lange eine Funktion läuft - ohne dass du die Funktion selbst anfassen musst. Praktisch, wenn eine Stelle im Code plötzlich zäh wird und du herausfinden willst, wo die Zeit verloren geht.

import time
from functools import wraps


def timer(funktion):
    @wraps(funktion)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        ergebnis = funktion(*args, **kwargs)
        dauer = time.perf_counter() - start
        print(f"{funktion.__name__} brauchte {dauer:.4f} Sekunden")
        return ergebnis

    return wrapper


@timer
def summe_berechnen():
    total = 0
    for i in range(1_000_000):
        total += i
    return total


ergebnis = summe_berechnen()
print(f"Ergebnis: {ergebnis}")

Drei Dinge sind hier neu und wichtig:

• `*args` und `**kwargs` sorgen dafür, dass der `wrapper` beliebige Argumente weiterreicht. So funktioniert dein Decorator mit jeder Funktion - egal welche Parameter sie erwartet.

• `time.perf_counter()` ist die empfohlene Uhr für Zeitmessungen, weil sie sehr präzise ist.

• `@wraps(funktion)` aus dem functools-Modul passt `__name__` und `__doc__` des Wrappers an. Mehr dazu gleich bei den Fehlern.

Übrigens: Wirft die dekorierte Funktion eine Exception, fliegt diese einfach durch den `wrapper` hindurch. Wie du solche Fehler gezielt abfängst, zeigt unser Artikel zum Python Exception Handling.

Häufige Fehler bei Python Decorators

Drei Klassiker schleichen sich immer wieder ein. So erkennst und behebst du sie:

Fehler 1: Das return vergessen

Der Klassiker unter Anfängerfehlern: Der `wrapper` wird definiert, aber nie zurückgegeben.

# FALSCH
def log_dekorator(funktion):
    def wrapper():
        funktion()

    # return wrapper fehlt!


# RICHTIG
def log_dekorator(funktion):
    def wrapper():
        funktion()

    return wrapper

Ohne das `return` liefert der Decorator `None` zurück. Der Aufruf `begruessung()` endet dann in einem `TypeError: 'NoneType' object is not callable` - du versuchst, `None` aufzurufen, als wäre es eine Funktion.

Fehler 2: Der Rückgabewert der Funktion geht verloren

Wenn deine dekorierte Funktion etwas zurückgeben soll, muss der `wrapper` das auch weiterreichen:

# FALSCH: Ergebnis verschwindet einfach
def wrapper(*args, **kwargs):
    funktion(*args, **kwargs)  # Rueckgabewert wird verworfen


# RICHTIG
def wrapper(*args, **kwargs):
    return funktion(*args, **kwargs)

Fehler 3: functools.wraps weglassen

Ohne `@wraps(funktion)` heißen alle deine dekorierten Funktionen plötzlich `wrapper`:

from functools import wraps


def ohne_wraps(funktion):
    def wrapper():
        pass

    return wrapper


@ohne_wraps
def meine_funktion():
    """Wichtige Dokumentation."""


print(meine_funktion.__name__)  # wrapper – der Name ist weg

Das klingt nach Kosmetik, wird aber zum Problem bei Debugging-Tools, Docstrings und Dokumentationsgeneratoren. Mit `@wraps(funktion)` bleiben Name und Doku erhalten.

Übungstipp: Schreib deinen eigenen Decorator

Nimm dir zehn Minuten und schreib einen `wiederhole_dekorator`, der eine Funktion zweimal hintereinander ausführt. Der `wrapper` ruft die Funktion dafür einfach zwei Mal auf. Klappt das, erweitere ihn so, dass die Anzahl der Wiederholungen konfigurierbar ist - dafür brauchst du einen Decorator mit eigenen Argumenten, der noch eine Schicht tiefer verschachtelt ist. Genau an dieser Stelle klickt das Konzept meistens richtig.

FAQ: Häufige Fragen zu Python Decorators

Was ist ein Decorator in Python?

Ein Decorator ist eine Funktion, die eine andere Funktion entgegennimmt und eine erweiterte Version davon zurückgibt. Mit der `@`-Syntax platzierst du ihn direkt über der Funktionsdefinition.

Wann setzt man Decorators ein?

Überall dort, wo Querschnittsfunktionalität über vielen Funktionen liegt:

• Logging: Aufrufe protokollieren

• Zeitmessung: langsamen Code aufspüren

• Caching: Ergebnisse zwischenspeichern

• Zugriffsprüfung: Berechtigungen checken

• Validierung: Eingaben prüfen

Muss man Decorators selbst schreiben?

Nein. Du nutzt sie ständig aus Bibliotheken: `@staticmethod`, `@classmethod` und `@property` in Klassen, `@app.route` in Flask oder `@pytest.fixture` in Tests. Sie selbst zu schreiben hilft aber enorm beim Verständnis.

Kann man mehrere Decorators kombinieren?

Ja, einfach untereinander notieren. Sie werden von unten nach oben angewendet - der unterste zuerst.

Was macht @functools.wraps?

Es kopiert Metadaten wie Funktionsname und Docstring vom Original auf den Wrapper. So heißen und dokumentieren sich dekorierte Funktionen korrekt.

Fazit

Python Decorators sind im Kern kein Hexenwerk: eine Funktion, die eine andere Funktion verpackt und die erweiterte Version zurückgibt. Das `@`-Zeichen ist nur die bequeme Schreibweise dafür. Wenn du das Prinzip einmal verinnerlicht hast, öffnen sich dir ganze Frameworks wie Flask oder Django neu - und du kannst eigenen Code mit Logging, Timing oder Prüfungen anreichern, ohne bestehende Funktionen anzufassen.

Wenn du bei Python, Java oder C# auf dem Schlauch stehst - ob für die nächste IHK-Prüfung, eine Klausur im Studium oder ein Projekt im Job - dann schau dir study-it.education an. Dort bekommst du individuelle Nachhilfe, die genau dort ansetzt, wo du gerade stehst.