Décorateurs Python avancés : élever votre code

Imaginez que vous êtes un chef dans une cuisine animée. Vous avez une recette, une fonction, si vous préférez. Au fil du temps, vous constatez que la plupart de vos plats nécessitent un filet d’huile d’olive, une pincée de sel ou une pincée d’herbes avant d’être servis. Au lieu d’ajouter manuellement ces touches finales à chaque plat, ne serait-il pas pratique d’avoir un assistant qui les applique automatiquement ? C'est précisément ce que les décorateurs Python peuvent faire pour votre code : ajouter des fonctionnalités de manière élégante, réutilisable et expressive.

Dans cet article, nous explorerons le monde des décorateurs Python avancés. Nous irons au-delà des bases en plongeant dans les décorateurs paramétrés, les décorateurs empilables et même les décorateurs avec classes. Nous mettrons également en avant les bonnes pratiques et les pièges à éviter. Prêt? Commençons à cuisiner !

Les bases revisitées

Avant de plonger dans le grand bain, revenons sur les fondations. Un décorateur en Python est simplement une fonction qui prend une autre fonction (ou méthode) comme argument, l'augmente et renvoie une nouvelle fonction. Voici un exemple :

# Basic decorator example
def simple_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}...")
        result = func(*args, **kwargs)
        print(f"{func.__name__} finished.")
        return result
    return wrapper

@simple_decorator
def say_hello():
    print("Hello, world!")

say_hello()

Sortie :

Calling say_hello...
Hello, world!
say_hello finished.

Passons maintenant aux cas d'utilisation avancés.

Décorateurs paramétrés

Parfois, un décorateur doit accepter ses propres arguments. Par exemple, que se passe-t-il si nous voulons un décorateur qui enregistre les messages à différents niveaux (INFO, DEBUG, ERROR) ?

# Parameterized decorator example
def log(level):
    def decorator(func):
        def wrapper(*args, **kwargs):
            print(f"[{level}] Calling {func.__name__}...")
            result = func(*args, **kwargs)
            print(f"[{level}] {func.__name__} finished.")
            return result
        return wrapper
    return decorator

@log("INFO")
def process_data():
    print("Processing data...")

process_data()

Sortie :

[INFO] Calling process_data...
Processing data...
[INFO] process_data finished.

Cette structure en couches (une fonction renvoyant un décorateur) est essentielle pour créer des décorateurs flexibles et paramétrés.

Décorateurs empilables

Python permet d'appliquer plusieurs décorateurs à une seule fonction. Créons deux décorateurs et empilons-les.

# Stackable decorators

def uppercase(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return result.upper()
    return wrapper

def exclaim(func):
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return result + "!!!"
    return wrapper

@uppercase
@exclaim
def greet():
    return "hello"

print(greet())

Sortie :

HELLO!!!

Ici, les décorateurs sont appliqués de bas en haut : @exclaim enveloppe le message d'accueil et @uppercase enveloppe le résultat.

Utiliser des classes comme décorateurs

Une fonctionnalité moins connue de Python est que les classes peuvent être utilisées comme décorateurs. Cela peut être particulièrement utile lorsque vous devez maintenir l'état.

# Class-based decorator
class CountCalls:
    def __init__(self, func):
        self.func = func
        self.call_count = 0

    def __call__(self, *args, **kwargs):
        self.call_count += 1
        print(f"Call {self.call_count} to {self.func.__name__}")
        return self.func(*args, **kwargs)

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

say_hello()
say_hello()

Sortie :

Call 1 to say_hello
Hello!
Call 2 to say_hello
Hello!

Ici, la méthode call permet à la classe de se comporter comme une fonction, lui permettant d'envelopper la fonction cible de manière transparente.

Décorateurs pour les méthodes

Les décorateurs travaillent tout aussi bien avec les méthodes en classe. Cependant, se comporter correctement est essentiel.

# Method decorator example
def log_method(func):
    def wrapper(self, *args, **kwargs):
        print(f"Method {func.__name__} called on {self}")
        return func(self, *args, **kwargs)
    return wrapper

class Greeter:
    @log_method
    def greet(self, name):
        print(f"Hello, {name}!")

obj = Greeter()
obj.greet("Alice")

Sortie :

Method greet called on <__main__.greeter object at>
Hello, Alice!
</__main__.greeter>

Combiner des décorateurs avec des gestionnaires de contexte

Parfois, vous devrez intégrer des décorateurs à la gestion des ressources. Par exemple, créons un décorateur qui chronomètre l'exécution d'une fonction.

import time

# Timing decorator
def time_it(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        end = time.time()
        print(f"{func.__name__} took {end - start:.2f} seconds")
        return result
    return wrapper

@time_it
def slow_function():
    time.sleep(2)
    print("Done sleeping!")

slow_function()

Sortie :

# Basic decorator example
def simple_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}...")
        result = func(*args, **kwargs)
        print(f"{func.__name__} finished.")
        return result
    return wrapper

@simple_decorator
def say_hello():
    print("Hello, world!")

say_hello()

Meilleures pratiques

Lorsque vous travaillez avec des décorateurs, il est crucial de garder à l'esprit la lisibilité et la maintenabilité. Voici quelques conseils :

• Utilisez functools.wraps : cela préserve les métadonnées de la fonction d'origine.

Calling say_hello...
Hello, world!
say_hello finished.

• Testez minutieusement : les décorateurs peuvent introduire des bugs subtils, en particulier lorsqu'ils enchaînent plusieurs décorateurs.

• Documenter les décorateurs : documentez clairement ce que fait chaque décorateur et ses paramètres attendus.

• Évitez la surutilisation : bien que les décorateurs soient puissants, leur utilisation excessive peut rendre le code difficile à suivre.

Conclusion

Les décorateurs sont l’une des fonctionnalités les plus expressives de Python. Ils vous permettent d'étendre et de modifier le comportement de manière propre et réutilisable. Des décorateurs paramétrés aux implémentations basées sur les classes, les possibilités sont infinies. Au fur et à mesure que vous perfectionnerez vos compétences, vous vous retrouverez à faire appel à des décorateurs pour écrire du code plus propre et plus pythonique et peut-être, comme un grand chef, à créer vos touches de signature dans chaque recette que vous élaborez.

remarque : contenu assisté par l'IA

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!