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

Quando si lavora con i **decoratori** in Python, spesso è necessario applicare più di un decoratore a una singola funzione. Questo è noto come **stacking** o **chaining dei decoratori**. Il modo in cui si impilano i decoratori consiste nel posizionare più righe di decoratori, una dopo l'altra, direttamente sopra la definizione della funzione. L'ordine in cui si impilano i decoratori è importante perché influisce su come la funzione viene avvolta e su come ciascun decoratore interagisce con gli altri. Il decoratore più vicino alla funzione viene applicato per primo, e ogni decoratore successivo avvolge il risultato di quello precedente. Questo significa che il decoratore in cima alla pila è l'involucro più esterno, mentre quello più vicino alla funzione è il più interno.

Nell'esempio seguente vengono definiti due decoratori, `decorator_one` e `decorator_two`, impilati sopra una funzione chiamata `greet`. L'ordine di impilamento determina come vengono applicati i decoratori.

# 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")

Nota che `decorator_two` viene applicato per primo a `greet`, e poi `decorator_one` avvolge il risultato. Questo significa che il decoratore più vicino alla funzione è il più interno, mentre quello più in alto è il più esterno. L'ordine di impilamento è importante, poiché influisce sul comportamento della funzione decorata.

Nota

In quale ordine vengono applicati i decoratori impilati in Python?

Apprendere le tecniche di packing/unpacking, argomenti flessibili per le funzioni, funzioni di ordine superiore, lambda, ambito delle variabili, closure, iteratori e decorator. Progettato per chi ha completato un corso introduttivo di Python e desidera scrivere codice più efficiente, espressivo e potente.

Esplora l'arte del packing e unpacking di liste, tuple e dizionari per scrivere codice Python più espressivo ed efficiente.

Esplora il mondo delle funzioni di ordine superiore, il passaggio di funzioni come argomenti e la scrittura di funzioni anonime concise con lambda.

Svela i misteri dell'ambito delle variabili e scopri come le funzioni annidate e le closure consentano un'incapsulamento potente.

Approfondimento sul protocollo di iterazione di Python, iteratori personalizzati e funzioni generatrici per un'elaborazione efficiente dei dati.

Concatenazione e Impilamento dei Decorator