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

Lors de l'utilisation des **décorateurs** en Python, il est souvent nécessaire d'appliquer plusieurs décorateurs à une même fonction. Cela s'appelle **empiler** ou **enchaîner des décorateurs**. Pour empiler des décorateurs, il suffit de placer plusieurs lignes de décorateur, l'une après l'autre, directement au-dessus de la définition de la fonction. L'ordre dans lequel les décorateurs sont empilés est important, car il influence la manière dont la fonction est enveloppée et la façon dont chaque décorateur interagit avec les autres. Le décorateur le plus proche de la fonction est appliqué en premier, et chaque décorateur suivant enveloppe le résultat du précédent. Ainsi, le décorateur situé en haut de la pile constitue l'enveloppe la plus externe, tandis que celui le plus proche de la fonction est l'enveloppe la plus interne.

L'exemple ci-dessous définit deux décorateurs, `decorator_one` et `decorator_two`, empilés au-dessus d'une fonction appelée `greet`. L'ordre d'empilement détermine la manière dont les décorateurs sont appliqués.

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

Remarquez que `decorator_two` est appliqué d'abord à `greet`, puis `decorator_one` enveloppe le résultat. Cela signifie que le décorateur le plus proche de la fonction est le plus interne, et celui du dessus est le plus externe. L'ordre d'empilement est important, car il influence le comportement de votre fonction décorée.

Remarque

Dans quel ordre les décorateurs empilés sont-ils appliqués en Python ?

Maîtrise de l'emballage/déballage, des arguments de fonction flexibles, des fonctions d'ordre supérieur, des lambdas, de la portée des variables, des closures, des itérateurs et des décorateurs. Conçu pour les apprenants ayant suivi un cours d'introduction à Python et souhaitant écrire un code plus efficace, expressif et puissant.

Explorez l'art du packing et unpacking des listes, tuples et dictionnaires pour écrire un code Python plus expressif et efficace.

Plongez dans le monde des fonctions d'ordre supérieur, du passage de fonctions en tant qu'arguments, et de l'écriture de fonctions anonymes concises avec lambda.

Démystifier la portée des variables et découvrir comment les fonctions imbriquées et les closures permettent une encapsulation puissante.

Plongez dans le protocole d'itération de Python, les itérateurs personnalisés et les fonctions génératrices pour un traitement efficace des données.

Enchaînement et empilement de décorateurs