Que sont les décorateurs à Python? Comment en créez-vous un?

Que sont les décorateurs à Python? Comment en créez-vous un?

Les décorateurs de Python sont un moyen puissant et élégant de modifier ou d'améliorer le comportement des fonctions ou des classes sans modifier directement leur code source. Ce sont essentiellement des fonctions qui prennent une autre fonction comme un argument et étendent ou modifient son comportement. Les décorateurs vous permettent d'envelopper une autre fonction afin d'exécuter du code avant et après l'exécution de la fonction enveloppée.

Pour créer un décorateur, vous pouvez suivre ces étapes:

1. Définissez la fonction du décorateur : écrivez une fonction qui prend une autre fonction comme son argument.
2. Définissez la fonction de wrapper : à l'intérieur de la fonction décoratrice, définissez une fonction d'emballage qui s'enroulera autour de la fonction d'origine.
3. Exécutez la fonction enveloppée : la fonction de wrapper doit appeler la fonction d'origine et peut également exécuter du code supplémentaire avant et après l'appel.
4. Renvoie l'emballage : la fonction décoratrice doit renvoyer la fonction de wrapper.

Voici un exemple de la façon de créer un décorateur simple:

 <code class="python">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 @my_decorator def say_hello(): print("Hello!") say_hello()</code>

Dans cet exemple, my_decorator est le décorateur, et say_hello est la fonction décorée. Lorsque say_hello est appelé, il exécutera le code dans la fonction wrapper .

Quels avantages les décorateurs offrent-ils dans la programmation Python?

Les décorateurs offrent plusieurs avantages clés dans la programmation Python:

1. Réutilisabilité du code : les décorateurs vous permettent d'appliquer les mêmes modifications ou améliorations à plusieurs fonctions sans répéter le code. Cela favorise le principe sec (ne vous répétez pas).
2. Séparation des préoccupations : En séparant la logique centrale d'une fonction des fonctionnalités supplémentaires (comme la journalisation, le calendrier ou l'authentification), les décorateurs aident à maintenir le code propre et ciblé.
3. Facilité d'entretien : Étant donné que les décorateurs sont appliqués à l'extérieur aux fonctions, des modifications peuvent être apportées au décorateur sans modifier la fonction décorée, ce qui facilite l'entretien.
4. Flexibilité et extensibilité : les décorateurs peuvent être empilés (plusieurs décorateurs appliqués à la même fonction), et ils peuvent également être paramétrés, permettant des améliorations très flexibles.
5. Limibilité et simplicité : la syntaxe @decorator est claire et concise, ce qui rend le code plus facile à lire et à comprendre.
6. Programmation axée sur l'aspect : les décorateurs facilitent la mise en œuvre de préoccupations croisées telles que la journalisation, la surveillance des performances et les contrôles de sécurité, qui sont communs à plusieurs fonctions.

Comment pouvez-vous utiliser les décorateurs pour modifier le comportement des fonctions?

Les décorateurs peuvent être utilisés pour modifier le comportement des fonctions de diverses manières. Voici quelques applications courantes:

1. Enregistrement : les décorateurs peuvent enregistrer les appels de fonction, les entrées, les sorties et les temps d'exécution à des fins de débogage et de surveillance.

    <code class="python">def log_decorator(func): def wrapper(*args, **kwargs): print(f"Calling {func.__name__}") result = func(*args, **kwargs) print(f"{func.__name__} finished execution") return result return wrapper @log_decorator def add(a, b): return ab</code>

2. Timing : Vous pouvez utiliser les décorateurs pour mesurer le temps d'exécution des fonctions, ce qui est utile pour l'optimisation des performances.

    <code class="python">import time def timer_decorator(func): def wrapper(*args, **kwargs): start_time = time.time() result = func(*args, **kwargs) end_time = time.time() print(f"{func.__name__} took {end_time - start_time} seconds to run.") return result return wrapper @timer_decorator def slow_function(): time.sleep(2) print("Slow function executed")</code>

3. Authentification et autorisation : les décorateurs peuvent être utilisés pour vérifier si un utilisateur est authentifié avant d'autoriser l'accès à certaines fonctions.

    <code class="python">def requires_auth(func): def wrapper(*args, **kwargs): if not authenticated: raise PermissionError("Authentication required") return func(*args, **kwargs) return wrapper @requires_auth def protected_function(): print("This function is protected")</code>

4. Mémuisation : les décorateurs peuvent mettre en cache les résultats des appels de fonction coûteux pour améliorer les performances.

    <code class="python">def memoize(func): cache = {} def wrapper(*args): if args in cache: return cache[args] result = func(*args) cache[args] = result return result return wrapper @memoize def fibonacci(n): if n </code>

Pouvez-vous expliquer un exemple pratique de la mise en œuvre d'un décorateur à Python?

Voyons un exemple pratique de la mise en œuvre d'un décorateur pour la mise en cache des résultats, ce qui peut améliorer considérablement les performances des fonctions coûteuses en calcul. Nous utiliserons une fonction Fibonacci pour le démontrer:

 <code class="python">def memoize(func): cache = {} def wrapper(*args): if args in cache: print(f"Returning cached result for {args}") return cache[args] result = func(*args) cache[args] = result print(f"Caching result for {args}") return result return wrapper @memoize def fibonacci(n): if n </code>

Dans cet exemple:

1. Memoize Decorator : Le décorateur memoize maintient un cache de dictionnaire pour stocker les résultats des appels de fonction. La fonction wrapper vérifie si le résultat d'un ensemble d'arguments donné est déjà dans le cache. Si c'est le cas, il renvoie le résultat mis en cache; Sinon, il calcule le résultat, le cache, puis le renvoie.
2. Fonction de Fibonacci : La fonction fibonacci calcule les nombres de Fibonacci récursivement. Sans la mémorisation, cela conduirait à de nombreux calculs redondants, en particulier pour les nombres plus importants. Le décorateur @memoize appliqué à fibonacci garantit que chaque numéro de Fibonacci n'est calculé qu'une seule fois et réutilisé pour les appels ultérieurs.
3. Exécution : lorsque fibonacci(10) est d'abord appelé, le décorateur calcule et mettra en cache le résultat. Lors du deuxième appel à fibonacci(10) , il récupérera le résultat du cache, démontrant l'amélioration des performances.

Cet exemple illustre comment les décorateurs peuvent être utilisés pour améliorer les performances des fonctions en mettant en œuvre la mémorisation, qui est une technique courante dans les scénarios d'optimisation et de programmation dynamique.

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!