Summary
This chapter covers stacking multiple decorators on a single function and explains that the decorator closest to the function is applied first, with each outer decorator wrapping the result of the previous one.

General domain of usage
Logging and instrumentation

Beim Arbeiten mit **Dekoratoren** in Python besteht häufig die Notwendigkeit, mehr als einen Dekorator auf eine einzelne Funktion anzuwenden. Dies wird als **Stapelung** oder **Verkettung von Dekoratoren** bezeichnet. Die Stapelung erfolgt, indem mehrere Dekorator-Zeilen direkt übereinander oberhalb der Funktionsdefinition platziert werden. Die Reihenfolge der Dekoratoren ist entscheidend, da sie beeinflusst, wie die Funktion umschlossen wird und wie die einzelnen Dekoratoren miteinander interagieren. Der Dekorator, der der Funktion am nächsten steht, wird zuerst angewendet, und jeder weitere Dekorator umschließt das Ergebnis des vorherigen. Das bedeutet, dass der oberste Dekorator der äußerste Wrapper ist, während derjenige, der der Funktion am nächsten steht, der innerste ist.

Im folgenden Beispiel werden zwei Dekoratoren, `decorator_one` und `decorator_two`, definiert und über einer Funktion namens `greet` gestapelt. Die Reihenfolge der Stapelung bestimmt, wie die Dekoratoren angewendet werden.

# Prints messages before and after the function call
def decorator_one(func):
    def wrapper(*args, **kwargs):
        print("Decorator One: Before")
        result = func(*args, **kwargs)
        print("Decorator One: After")
        return result
    return wrapper

# Also prints messages before and after the function call
def decorator_two(func):
    def wrapper(*args, **kwargs):
        print("Decorator Two: Before")
        result = func(*args, **kwargs)
        print("Decorator Two: After")
        return result
    return wrapper

# Stacking decorators
# decorator_two is applied first (innermost),
# then decorator_one wraps the result (outermost)
@decorator_one
@decorator_two
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")

Beachte, dass `decorator_two` zuerst auf `greet` angewendet wird und anschließend `decorator_one` das Ergebnis umschließt. Das bedeutet, dass der Dekorator, der der Funktion am nächsten steht, der innerste ist, und der oberste der äußerste. Die Reihenfolge des Stapelns ist wichtig, da sie das Verhalten der dekorierten Funktion beeinflusst.

Hinweis

In welcher Reihenfolge werden gestapelte Dekoratoren in Python angewendet?

Beherrschung von Packing/Unpacking, flexiblen Funktionsargumenten, Higher-Order-Funktionen, Lambdas, Variablenbereich, Closures, Iteratoren und Dekoratoren. Konzipiert für Lernende, die einen Einführungskurs in Python abgeschlossen haben und effizienteren, ausdrucksstärkeren und leistungsfähigeren Code schreiben möchten.

Erkunden Sie die Kunst des Packens und Entpackens von Listen, Tupeln und Dictionaries, um ausdrucksstärkeren und effizienteren Python-Code zu schreiben.

Tauchen Sie ein in die Welt der höherwertigen Funktionen, das Übergeben von Funktionen als Argumente und das Schreiben prägnanter anonymer Funktionen mit Lambda.

Entschlüsseln der Geheimnisse des Variablenbereichs und Erlernen, wie verschachtelte Funktionen und Closures eine leistungsstarke Kapselung ermöglichen.

Vertiefung in das Iterationsprotokoll von Python, benutzerdefinierte Iteratoren und Generatorfunktionen für effiziente Datenverarbeitung.

Verkettung und Stapelung von Dekoratoren