Introduction aux decorators

Les decorators sont une fonctionnalité puissante de Python qui permet de modifier le comportement des fonctions ou des méthodes. Ils servent souvent à ajouter des fonctionnalités aux fonctions sans modifier leur code.

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

Qu’est-ce qu’un decorator ?

Un decorator 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()

Fonctionnement des decorators

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

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

Utiliser des decorators avec des arguments

Les decorators 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))

Chaînage de plusieurs décorateurs

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()

Création de décorateurs paramétrés

Les décorateurs paramétrés acceptent des arguments et offrent davantage de souplesse :

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

Cas d'utilisation courants des décorateurs

Les décorateurs sont couramment utilisés pour :

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

Décorateurs intégrés à Python

Python fournit plusieurs 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é.

Erreurs courantes avec les décorateurs

Voici quelques erreurs à éviter :

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

Qu'avez-vous appris

Dans cette leçon, vous avez appris :

• Ce que sont les décorateurs et comment ils fonctionnent dans 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 à Python.

Excellent travail ! Passons au sujet suivant.