Décorateurs Python : un guide complet

Quand j'ai commencé à programmer avec Python, si je ne me trompe pas, la version était la 3.3. Par conséquent, lorsque j'ai commencé à programmer, les décorateurs étaient disponibles depuis longtemps pour la communauté Python.

Les décorateurs de fonctions sont arrivés sur Python avec la version 2.2 et les décorateurs de classes sont arrivés sur Python avec la version 2.6.

Personnellement, je considère la fonctionnalité Decorator de Python comme une fonctionnalité très puissante du langage.

En fait, mon objectif est de faire une série d'articles sur les sujets les plus difficiles à comprendre en Python. Je compte aborder ces sujets, qui sont un peu plus d'une dizaine, un par un.

Dans cet article, j'essaierai d'aborder autant que possible chaque partie du sujet des décorateurs.

1. Contexte historique

• Premiers jours (pré-Python 2.2) : Avant les décorateurs, la modification de fonctions ou de classes impliquait souvent un emballage manuel ou un patch singe, ce qui était fastidieux et moins lisible.
• Métaclasses (Python 2.2) : Les métaclasses fournissaient un moyen de contrôler la création de classes, offrant certaines des fonctionnalités que les décorateurs fourniraient plus tard, mais elles étaient complexes pour des modifications simples.
• PEP 318 (Python 2.4) : Les décorateurs ont été formellement introduits dans Python 2.4 via PEP 318. La proposition s'inspire des annotations en Java et visait à fournir une manière plus propre et plus déclarative de modifier les fonctions et les méthodes. .
• Décorateurs de classe (Python 2.6) : Python 2.6 a étendu la prise en charge des décorateurs aux classes, améliorant encore leur polyvalence.
• Adoption généralisée : Les décorateurs sont rapidement devenus une fonctionnalité populaire, largement utilisée dans des frameworks comme Flask et Django pour le routage, l'authentification, etc.

2. Que sont les décorateurs ?

Essentiellement, un décorateur est un modèle de conception en Python qui vous permet de modifier le comportement d'une fonction ou d'une classe sans changer sa structure de base. Les décorateurs sont une forme de métaprogrammation, dans laquelle vous écrivez essentiellement du code qui manipule d'autres codes.

Vous savez que Python résout les noms en utilisant la portée indiquée dans l'ordre ci-dessous :

1. Local
2. Enfermant
3. Mondial
4. Intégré

Les décorateurs sont assis dans la portée Enclosing, qui est étroitement liée au concept de Closure.

Idée clé : Un décorateur prend une fonction en entrée, y ajoute des fonctionnalités et renvoie une fonction modifiée.

Analogie : Pensez à un décorateur comme à un emballage cadeau. Vous avez un cadeau (la fonction originale) et vous l'enveloppez avec du papier décoratif (le décorateur) pour le rendre plus joli ou ajouter des fonctionnalités supplémentaires (comme un nœud ou une carte). Le cadeau à l'intérieur reste le même, mais sa présentation ou les actions associées sont valorisées.

A) Variations du décorateur : basées sur la fonction ou basées sur la classe

La plupart des décorateurs en Python sont implémentés à l'aide de fonctions, mais vous pouvez également créer des décorateurs à l'aide de classes.
Les décorateurs basés sur les fonctions sont plus courants et plus simples, tandis que les décorateurs basés sur les classes offrent une flexibilité supplémentaire.

Syntaxe du décorateur de base basée sur les fonctions

def my_decorator(func):
    def wrapper(*args, **kwargs):
        # Do something before calling the decorated function
        print("Before function call")
        result = func(*args, **kwargs)
        # Do something after calling the decorated function
        print("After function call")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("World")

Explication :

• my_decorator est la fonction décorateur. Il faut que la fonction func soit décorée en entrée.
• wrapper est une fonction interne qui encapsule l'appel de la fonction d'origine. Il peut exécuter du code avant et après la fonction d'origine.
• @my_decorator est la syntaxe du décorateur. C'est équivalent à say_hello = my_decorator(say_hello).

Syntaxe du décorateur de base basée sur les classes

Ceux-ci utilisent des classes au lieu de fonctions pour définir les décorateurs.

class MyDecorator:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        # Do something before calling the decorated function
        print("Before function call")
        result = self.func(*args, **kwargs)
        # Do something after calling the decorated function
        print("After function call")
        return result

@MyDecorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("World")

Explication :

• MyDecorator est une classe qui fait office de décorateur.
• La méthode __init__ stocke la fonction à décorer.
• La méthode __call__ rend l'instance de classe appelable, lui permettant d'être utilisée comme une fonction.

---

B) Mise en œuvre d'un décorateur simple

Le concept fondamental des décorateurs est que ce sont des fonctions qui prennent une autre fonction comme argument et étendent son comportement sans la modifier explicitement.
Voici le formulaire le plus simple :

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

# Using the decorator with @ syntax
@my_decorator
def say_hello():
    print("Hello!")

# When we call say_hello()
say_hello()

# This is equivalent to:
# say_hello = my_decorator(say_hello)

C) Implémentation d'un décorateur avec des arguments

Créons un décorateur qui enregistre le temps d'exécution d'une fonction :

def decorator_with_args(func):
    def wrapper(*args, **kwargs):    # Accept any number of arguments
        print(f"Arguments received: {args}, {kwargs}")
        return func(*args, **kwargs)  # Pass arguments to the original function
    return wrapper

@decorator_with_args
def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Alice", greeting="Hi")  # Prints arguments then "Hi, Alice!"

D) Implémentation d'un décorateur paramétré

Ce sont des décorateurs qui peuvent accepter leurs propres paramètres :

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

@repeat(times=3)
def greet(name):
    print(f"Hello {name}")
    return "Done"

greet("Bob")  # Prints "Hello Bob" three times

E) Implémentation d'un décorateur de classe

def singleton(cls):
    instances = {}
    def get_instance(*args, **kwargs):
        if cls not in instances:
            instances[cls] = cls(*args, **kwargs)
        return instances[cls]
    return get_instance

@singleton
class DatabaseConnection:
    def __init__(self):
        print("Initializing database connection")

# Creating multiple instances actually returns the same instance
db1 = DatabaseConnection()  # Prints initialization
db2 = DatabaseConnection()  # No initialization printed
print(db1 is db2)  # True

F) Implémentation des décorateurs de méthodes

Ceux-ci sont spécialement conçus pour les méthodes de classe :

def debug_method(func):
    def wrapper(self, *args, **kwargs):
        print(f"Calling method {func.__name__} of {self.__class__.__name__}")
        return func(self, *args, **kwargs)
    return wrapper

class MyClass:
    @debug_method
    def my_method(self, x, y):
        return x + y

obj = MyClass()
print(obj.my_method(5, 3))

G) Implémentation du chaînage de décorateurs

Plusieurs décorateurs peuvent être appliqués à une seule fonction :

def bold(func):
    def wrapper():
        return "<b>" + func() + "</b>"
    return wrapper

def italic(func):
    def wrapper():
        return "<i>" + func() + "</i>"
    return wrapper

@bold
@italic
def greet():
    return "Hello!"

print(greet())  # Outputs: <b><i>Hello!</i></b>

Explication :

• Les décorateurs sont appliqués de bas en haut.
• C'est plutôt dans ce qu'on fait en maths : f(g(x)).
• l'italique est appliqué en premier, puis le gras.

H) Que se passe-t-il si nous n'utilisons pas @functools.wraps ?

Le décorateur functools.wraps, Voir la documentation, est une fonction d'assistance qui préserve les métadonnées de la fonction d'origine (comme son nom, sa docstring et sa signature) lorsque vous l'enveloppez avec un décorateur. Si vous ne l'utilisez pas, vous perdrez ces informations importantes.

Exemple :

def my_decorator(func):
    def wrapper(*args, **kwargs):
        """Wrapper docstring"""
        return func(*args, **kwargs)
    return wrapper

@my_decorator
def my_function():
    """My function docstring"""
    pass

print(my_function.__name__)
print(my_function.__doc__)

Sortie :

wrapper
Wrapper docstring

Problème :

• Le nom de la fonction d'origine (my_function) et la docstring ("Ma fonction docstring") sont perdus.
• Cela peut rendre le débogage et l'introspection difficiles.

Solution : utilisez functools.wraps) :

def my_decorator(func):
    def wrapper(*args, **kwargs):
        # Do something before calling the decorated function
        print("Before function call")
        result = func(*args, **kwargs)
        # Do something after calling the decorated function
        print("After function call")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("World")

Sortie :

class MyDecorator:
    def __init__(self, func):
        self.func = func

    def __call__(self, *args, **kwargs):
        # Do something before calling the decorated function
        print("Before function call")
        result = self.func(*args, **kwargs)
        # Do something after calling the decorated function
        print("After function call")
        return result

@MyDecorator
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("World")

Avantages de functools.wraps :

• Préserve les métadonnées de la fonction.
• Améliore la lisibilité et la maintenabilité du code.
• Facilite le débogage.
• Aide avec les outils d'introspection et les générateurs de documentation.

I) Décorateurs avec Etat

Les décorateurs peuvent également conserver l’état entre les appels de fonction. Ceci est particulièrement utile pour des scénarios tels que la mise en cache ou le comptage des appels de fonction.

def my_decorator(func):
    def wrapper():
        print("Something is happening before the function is called.")
        func()
        print("Something is happening after the function is called.")
    return wrapper

# Using the decorator with @ syntax
@my_decorator
def say_hello():
    print("Hello!")

# When we call say_hello()
say_hello()

# This is equivalent to:
# say_hello = my_decorator(say_hello)

Sortie :

def decorator_with_args(func):
    def wrapper(*args, **kwargs):    # Accept any number of arguments
        print(f"Arguments received: {args}, {kwargs}")
        return func(*args, **kwargs)  # Pass arguments to the original function
    return wrapper

@decorator_with_args
def greet(name, greeting="Hello"):
    print(f"{greeting}, {name}!")

greet("Alice", greeting="Hi")  # Prints arguments then "Hi, Alice!"

Explication :

La fonction wrapper maintient un compteur (appels) qui s'incrémente à chaque fois que la fonction décorée est appelée.
Ceci est un exemple simple de la façon dont les décorateurs peuvent être utilisés pour maintenir l'état.

J) Meilleures pratiques pour les décorateurs Python

• Utilisez functools.wraps : Utilisez toujours @functools.wraps dans vos décorateurs pour préserver les métadonnées de la fonction d'origine.
• Gardez les décorateurs simples : Les décorateurs devraient idéalement faire une chose spécifique et bien la faire. Cela les rend plus réutilisables et plus faciles à comprendre.
• Documentez vos décorateurs : Expliquez ce que fait votre décorateur, quels arguments il prend et ce qu'il renvoie.
• Testez vos décorateurs : Écrivez des tests unitaires pour vous assurer que vos décorateurs fonctionnent comme prévu dans divers scénarios.
• Considérez l'ordre d'enchaînement : Soyez attentif à l'ordre lorsque vous enchaînez plusieurs décorateurs, car il affecte le flux d'exécution.

K) Mauvaises implémentations (anti-modèles)

• Décorateurs trop complexes : Évitez de créer des décorateurs trop complexes ou d'essayer de faire trop de choses. Cela les rend difficiles à comprendre, à maintenir et à déboguer.
• Ignorer functools.wraps : Oublier d'utiliser @functools.wraps entraîne une perte des métadonnées de fonction, ce qui peut entraîner des problèmes d'introspection et de débogage.
• Effets secondaires : Les décorateurs ne devraient idéalement pas avoir d'effets secondaires involontaires en dehors de la modification de la fonction décorée.
• Valeurs de codage en dur : Évitez les valeurs de codage en dur au sein des décorateurs. Utilisez plutôt des usines de décorateurs pour les rendre configurables.
• Ne pas gérer correctement les arguments : Assurez-vous que votre fonction wrapper peut gérer un nombre illimité d'arguments de position et de mots-clés en utilisant *args et **kwargs si le décorateur est destiné à être utilisé avec une variété de fonctions.

L) 10. Cas d'utilisation réels

• Journalisation : Enregistrement des appels de fonction, des arguments et des valeurs de retour pour le débogage ou l'audit.
• Timing : Mesure du temps d'exécution des fonctions pour l'analyse des performances.
• Mise en cache : Stockage des résultats d'appels de fonctions coûteux pour éviter les calculs redondants (mémorisation).
• Authentification et autorisation : Vérifier les informations d'identification ou les autorisations de l'utilisateur avant d'exécuter une fonction.
• Validation des entrées : Vérifier si les arguments passés à une fonction répondent à certains critères.
• Limitation du taux : Contrôler le nombre de fois qu'une fonction peut être appelée au cours d'une période de temps spécifique.
• Réessayer logique : Réessayer automatiquement un appel de fonction s'il échoue en raison d'une erreur temporaire.
• Tâches spécifiques au framework : Les frameworks comme Flask et Django utilisent des décorateurs pour le routage (mapping des URL aux fonctions), l'enregistrement des plugins, et bien plus encore.

M) Listes organisées de décorateurs Python

Vous pouvez trouver ci-dessous une liste organisée de décorateurs Python :

• Superbes décorateurs Python
• Bibliothèque de décorateurs Python

N) 11. Conclusion

Les décorateurs sont une fonctionnalité puissante et élégante de Python qui vous permet d'améliorer les fonctions et les classes de manière propre et déclarative.
En comprenant les principes, les meilleures pratiques et les pièges potentiels, vous pouvez exploiter efficacement les décorateurs pour écrire un code plus modulaire, maintenable et expressif.
Ils constituent un outil précieux dans l'arsenal de tout programmeur Python, en particulier lorsqu'il travaille avec des frameworks ou crée des composants réutilisables.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!