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

Al trabajar con **decoradores** en Python, a menudo es necesario aplicar más de un decorador a una sola función. Esto se conoce como **apilamiento** o **encadenamiento de decoradores**. La forma de apilar decoradores es colocando varias líneas de decoradores, una tras otra, directamente encima de la definición de la función. El orden en que se apilan los decoradores es importante porque afecta cómo se envuelve la función y cómo interactúa cada decorador con los demás. El decorador más cercano a la función se aplica primero, y cada decorador subsiguiente envuelve el resultado del anterior. Esto significa que el decorador en la parte superior de la pila es el envoltorio más externo, mientras que el más cercano a la función es el más interno.

El siguiente ejemplo define dos decoradores, `decorator_one` y `decorator_two`, apilados sobre una función llamada `greet`. El orden de apilamiento determina cómo se aplican los decoradores.

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

Observa que `decorator_two` se aplica primero a `greet`, y luego `decorator_one` envuelve el resultado. Esto significa que el decorador más cercano a la función es el más interno, y el superior es el más externo. El orden de apilamiento es importante, ya que afecta el comportamiento de tu función decorada.

Nota

¿En qué orden se aplican los decoradores apilados en Python?

Domina el empaquetado/desempaquetado, argumentos flexibles en funciones, funciones de orden superior, lambdas, alcance de variables, closures, iteradores y decoradores. Diseñado para estudiantes que han completado un curso introductorio de Python y desean escribir código más eficiente, expresivo y potente.

Explora el arte de empaquetar y desempaquetar listas, tuplas y diccionarios para escribir código Python más expresivo y eficiente.

Adentrarse en el mundo de las funciones de orden superior, el paso de funciones como argumentos y la escritura de funciones anónimas concisas con lambda.

Descubre los misterios del alcance de las variables y aprende cómo las funciones anidadas y los closures permiten una encapsulación poderosa.

Profundización en el protocolo de iteración de Python, iteradores personalizados y funciones generadoras para el procesamiento eficiente de datos.

Encadenamiento y Apilamiento de Decoradores