Décorateurs

Les décorateurs sont une fonctionnalité puissante de Python qui vous permet de modifier le comportement de fonctions ou de méthodes. Ils sont souvent utilisés pour ajouter des fonctionnalités à des fonctions sans modifier leur code.

Dans cette leçon, vous découvrirez ce que sont les décorateurs, comment les utiliser et comment créer vos propres décorateurs.

Un décorateur est une fonction qui prend une autre fonction en entrée et renvoie une nouvelle fonction dotée de fonctionnalités supplémentaires. Il est souvent utilisé avec la syntaxe @decorator_name.

# Basic example of a decorator
def decorator(func):
    def wrapper():
        print("Before the function call")
        func()
        print("After the function call")
    return wrapper

@decorator
def say_hello():
    print("Hello!")

say_hello()

Lorsque vous utilisez un décorateur, Python remplace la fonction d'origine par la fonction wrapper renvoyée par le décorateur.

# How decorators work
def decorator(func):
    def wrapper():
        print("Wrapper called")
        func()
    return wrapper

@decorator
def greet():
    print("Greetings!")

print(greet.__name__)  # Outputs: wrapper
greet()

Les décorateurs peuvent fonctionner avec des fonctions qui prennent des arguments en utilisant *args et **kwargs dans la fonction wrapper :

# Decorator for functions with arguments
def decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Arguments: {args}, {kwargs}")
        return func(*args, **kwargs)
    return wrapper

@decorator
def add(a, b):
    return a + b

print(add(3, 5))

Vous pouvez utiliser plusieurs décorateurs sur une même fonction. Ils sont appliqués dans l'ordre où ils apparaissent, de haut en bas :

# Chaining multiple decorators
def decorator1(func):
    def wrapper():
        print("Decorator 1")
        func()
    return wrapper

def decorator2(func):
    def wrapper():
        print("Decorator 2")
        func()
    return wrapper

@decorator1
@decorator2
def greet():
    print("Hello!")

greet()

Les décorateurs paramétrés acceptent des arguments et permettent une fonctionnalité plus flexible :

# Parameterized decorator
def repeat(times):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(3)
def say_hello():
    print("Hello!")

say_hello()

Les décorateurs sont couramment utilisés pour :

• Consigner les appels de fonctions et leurs arguments.
• Mesurer le temps d’exécution des fonctions.
• Contrôler les accès, par exemple en vérifiant les autorisations des utilisateurs.
• Mettre en cache les résultats afin d’améliorer les performances.

Python fournit certains décorateurs intégrés, notamment :

• @staticmethod : définit une méthode statique.
• @classmethod : définit une méthode de classe.
• @property : définit une méthode de propriété.

Voici quelques erreurs à éviter :

• Ne pas conserver le nom et la chaîne de documentation de la fonction d'origine (utilisez functools.wraps).
• Utiliser des décorateurs inutilement pour des tâches simples.
• Oublier de gérer les arguments dans la fonction wrapper.

Dans cette leçon, vous avez appris :

• Ce que sont les décorateurs et comment ils fonctionnent en Python.
• Comment créer et utiliser des décorateurs simples, paramétrés et chaînés.
• Les cas d’utilisation courants et les décorateurs intégrés de Python.

Excellent travail ! Passons au sujet suivant.