Décorateurs Python : meilleure compréhension de l'amélioration des fonctionnalités

Allons au-delà des bases pour comprendre les décorateurs en profondeur. Les décorateurs ne se limitent pas à des « couches supplémentaires », mais offrent un moyen sophistiqué d’ajouter des fonctionnalités aux fonctions de manière dynamique, les rendant hautement adaptables et puissantes.

1. Qu'est-ce qu'un décorateur ?

Essentiellement, un décorateur est une fonction d'ordre supérieur : une fonction qui accepte une autre fonction comme argument, ajoute des fonctionnalités et renvoie une nouvelle fonction. Cela nous permet de « décorer » une fonction originale avec des capacités supplémentaires, en laissant la fonction originale inchangée.

Récapitulatif de la syntaxe :

@decorator_name
def my_function():
    pass

Utiliser @decorator_name avant my_function est un raccourci pour :

my_function = decorator_name(my_function)

2. Construire un décorateur de base

Construisons un décorateur simple qui enregistre lorsqu'une fonction est appelée.

def log_call(func):
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@log_call
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")  # Outputs: Calling greet, then Hello, Alice!

• log_call est un décorateur qui enveloppe les salutations.
• *args et `kwargs`** garantissent qu'il fonctionne avec n'importe quel nombre d'arguments de position ou de mot-clé.

3. Cas d'utilisation réels

Les décorateurs sont couramment utilisés pour :

• Contrôle d'accès : par exemple, vérifier les autorisations des utilisateurs.
• Mise en cache : Stockage des résultats d'appels de fonctions coûteux.
• Mécanismes de nouvelle tentative : Réessayer automatiquement une fonction en cas d'échec.
• Validation des entrées : vérification des arguments avant l'exécution d'une fonction.

4. Décorateurs avec arguments

Parfois, les décorateurs ont besoin de paramètres supplémentaires. Dans ces cas, nous ajoutons une fonction externe pour transmettre les paramètres au décorateur.

Exemple :

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()  # Outputs "Hello!" three times

Ici, repeat est une fabrique de décorateurs qui génère un décorateur basé sur l'argument times.

5. Décorateurs empilables

Vous pouvez empiler plusieurs décorateurs sur une seule fonction, créant ainsi une puissante chaîne de comportements.

Exemple :

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

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

@make_bold
@make_italic
def greet():
    return "Hello!"

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

Les enveloppes empilables @make_bold et @make_italic se saluent dans des balises grasses et italiques.

6. Préserver les métadonnées avec functools.wraps

Lors de la décoration de fonctions, vous souhaiterez souvent que les métadonnées de la fonction d'origine (comme son nom et sa docstring) soient préservées. Utilisez functools.wraps pour vous assurer que votre wrapper n'écrase pas ces détails.

from functools import wraps

def log_call(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Calling {func.__name__}")
        return func(*args, **kwargs)
    return wrapper

@wraps(func) garantit que le nom et la docstring de la fonction sont conservés.

7. Décorateurs en classes

Les décorateurs ne sont pas uniquement destinés à des fonctions autonomes ; ils peuvent également être utilisés avec des méthodes de classe.

Exemple :

@decorator_name
def my_function():
    pass

Le décorateur require_auth vérifie si l'utilisateur est authentifié avant d'autoriser l'accès à la méthode access_dashboard.

Conclusion : Boostez votre code avec des décorateurs

Les décorateurs sont un élément inestimable de Python, vous permettant d'améliorer, de modifier et de contrôler le comportement des fonctions de manière flexible et réutilisable. Ils rendent votre code plus expressif, modulaire et élégant. Avec les décorateurs, vous n'ajoutez pas seulement des fonctionnalités : vous affinez et enrichissez votre base de code.

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!