Comment utiliser et enchaîner efficacement les décorateurs en Python ?

Comment créer et chaîner des décorateurs en Python

Création de décorateurs

Écrire une fonction de décorateur qui prend une autre fonction, appelée une fonction "encapsulée", en argument :

def my_decorator(func):

    # Code to execute before calling the wrapped function
    print("Before the function runs")

    # Call the wrapped function and store its return value
    result = func()

    # Code to execute after calling the wrapped function
    print("After the function runs")

    # Return the result of the wrapped function
    return result

# Example of a decorator in action
@my_decorator
def say_hello():
    print("Hello, world!")

Chaînage Décorateurs

Utilisez l'opérateur @ pour appliquer plusieurs décorateurs à la même fonction :

@my_decorator
@another_decorator
def chained_function():
    print("This function is doubly decorated")

Décorateurs avec arguments

Autoriser les décorateurs à accepter les arguments :

def decorator_with_arg(arg1, arg2):

    def decorator(func):

        # Use the decorator arguments to modify the wrapped function's behavior
        func.arg1 = arg1
        func.arg2 = arg2

        return func

# Example of a decorator with arguments
@decorator_with_arg("foo", "bar")
def my_function():
    print("Args:", my_function.arg1, my_function.arg2)

Décorateurs pour la classe Méthodes

Utiliser des décorateurs pour les méthodes d'une classe :

class MyClass:

    @classmethod
    def my_class_method(cls):
        print("This is a class method")

Pratique : Décorer un décorateur

Créer un décorateur qui fait n'importe quel les autres décorateurs acceptent les arguments :

def decorator_with_args(decorator_to_enhance):

    def decorator_maker(*args, **kwargs):

        def decorator_wrapper(func):

            # Wrap the original decorator and pass the arguments
            return decorator_to_enhance(func, *args, **kwargs)

        return decorator_wrapper


# Example of a decorated decorator
@decorator_with_args
def decorated_decorator(func, *args, **kwargs):
    print("Args:", args, kwargs)
    return func


@decorated_decorator(10, 20, name="John")
def my_function():
    print("Decorated function")

Meilleur Pratiques

• Évitez de ralentir le code en raison de la surcharge du décorateur.
• Utilisez functools.wraps() pour conserver les informations de la fonction d'origine.
• Les décorateurs sont permanents une fois appliqués à une fonction.
• Envisagez de les utiliser pour déboguer ou étendre les fonctionnalités existantes à partir de sources externes. bibliothèques.

Exemples d'utilisation

Utiliser des décorateurs pour des tâches telles que :

• Mesurer le temps d'exécution d'une fonction (@benchmark)
• Journalisation des appels de fonction (@logging)
• Comptage des appels de fonction (@counter)
• Résultats de la fonction de mise en cache

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!