Création et chaînage de décorateurs de fonctions en Python

Améliorer les fonctions Python avec les décorateurs

En Python, les décorateurs sont un outil puissant pour modifier le comportement des fonctions ou des méthodes. Ils permettent aux développeurs d’envelopper des fonctionnalités supplémentaires autour d’une fonction existante de manière claire et lisible. En comprenant comment créer et enchaîner des décorateurs, vous pouvez grandement améliorer la modularité et la lisibilité de votre code.

Cet article vous guidera dans le processus de création de deux décorateurs spécifiques : un pour mettre le texte en gras et un autre pour mettre le texte en italique. Nous montrerons également comment enchaîner ces décorateurs pour obtenir le résultat souhaité. À la fin de ce didacticiel, vous serez en mesure d'appeler une fonction simple et de recevoir une chaîne formatée avec des balises HTML en gras et en italique.

Comprendre les décorateurs de fonctions Python

Les scripts fournis montrent comment créer et chaîner des décorateurs de fonctions en Python pour modifier le comportement des fonctions. Un décorateur en Python est défini à l'aide du def mot-clé pour créer une fonction qui prend une autre fonction comme argument et renvoie une nouvelle fonction. Le make_bold decorator enveloppe le résultat de la fonction qu'il décore avec des balises HTML en gras en utilisant le formatage f-string : f"<b>{func()}</b>". De même, le make_italic decorator enveloppe le résultat dans des balises italiques : f"<i>{func()}</i>". Lorsque ces décorateurs sont appliqués à une fonction en utilisant le @decorator_name syntaxe, ils modifient la sortie de la fonction en ajoutant les balises HTML respectives.

Le deuxième script introduit une approche plus polyvalente en créant une fonction d'ordre supérieur, add_html_tag, qui génère des décorateurs pour toute balise HTML spécifiée. Cette fonction prend une balise HTML comme argument et renvoie un décorateur qui encapsule la sortie de la fonction dans la balise spécifiée : f"<{tag}>{func()}</{tag}>". En utilisant @add_html_tag("b") et @add_html_tag("i"), nous pouvons chaîner ces décorateurs pour envelopper la sortie du dix fonctionner dans les balises en gras et en italique, ce qui donne le " souhaitéBonjour". Ces exemples illustrent la puissance et la flexibilité des décorateurs Python pour améliorer et personnaliser le comportement des fonctions de manière propre et réutilisable.

def make_bold(func):
    def wrapper():
        return f"<b>{func()}</b>"
    return wrapper

def make_italic(func):
    def wrapper():
        return f"<i>{func()}</i>"
    return wrapper

@make_bold
@make_italic
def say():
    return "Hello"

print(say())

def add_html_tag(tag):
    def decorator(func):
        def wrapper():
            return f"<{tag}>{func()}</{tag}>"
        return wrapper
    return decorator

@add_html_tag("b")
@add_html_tag("i")
def say_hello():
    return "Hello"

print(say_hello())

Techniques avancées de décoration Python

Au-delà de la simple modification de fonctions, les décorateurs Python offrent un moyen puissant d'améliorer la réutilisabilité et la maintenabilité du code. Un cas d'utilisation avancé est celui des décorateurs paramétrés, qui permettent aux décorateurs d'accepter des arguments. Cette technique a été illustrée par le add_html_tag décorateur dans les exemples précédents. En définissant un décorateur qui génère d'autres décorateurs, nous pouvons créer des structures de code très flexibles et réutilisables. Les décorateurs paramétrés nous permettent de transmettre des paramètres au décorateur lui-même, permettant ainsi des modifications dynamiques et spécifiques au contexte du comportement de la fonction.

Un autre aspect important des décorateurs est leur capacité à conserver les métadonnées de fonction. Lorsqu'une fonction est encapsulée par un décorateur, ses métadonnées, telles que son nom et sa docstring, peuvent être perdues. Pour préserver ces métadonnées, Python functools.wraps est utilisé au sein du décorateur. En postulant @functools.wraps Dans la fonction wrapper, les métadonnées de la fonction d'origine sont copiées, garantissant ainsi que les outils s'appuyant sur ces métadonnées, tels que les générateurs de documentation, continuent de fonctionner correctement. De plus, les décorateurs peuvent être empilés, comme indiqué avec le @make_bold et @make_italic exemples, pour appliquer plusieurs couches de modification de comportement de manière claire et lisible.