Décorateurs Python : simplifier le code

Les décorateurs en Python sont un outil puissant qui vous permet de modifier le comportement des fonctions ou des méthodes sans changer leur code source. Ils offrent un moyen simple d'ajouter des fonctionnalités et sont largement utilisés pour la journalisation, l'application de règles et l'optimisation des performances.

Dans cet article, nous examinerons six décorateurs Python courants avec des exemples simples.

1 - @staticmethod : Définir des méthodes statiques

Le décorateur @staticmethod crée des méthodes qui n'accèdent pas aux données d'instance (self) ou de classe (cls). Elle se comporte comme une fonction normale mais peut être appelée depuis la classe ou une instance.

Exemple :

class MyClass:
    @staticmethod
    def greet():
        return "Hello from static method!"

2 - @classmethod : Définir les méthodes de classe

Le décorateur @classmethod vous permet de définir des méthodes qui prennent la classe (cls) comme premier argument. Ceci est utile pour les méthodes d'usine ou pour modifier l'état de la classe.

Exemple :

class MyClass:
    count = 0

    @classmethod
    def increment_count(cls):
        cls.count += 1

3 - @property : Définir les attributs en lecture seule

Le décorateur @property permet d'accéder aux méthodes comme aux attributs. C'est utile lorsque vous souhaitez contrôler l'accès à une propriété sans exposer l'implémentation interne.

Exemple :

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def area(self):
        return 3.14 * self._radius ** 2

4 - @functools.lru_cache : Cache les résultats des fonctions coûteuses

Le décorateur @lru_cache (de functools) met en cache les résultats des appels de fonction pour éviter un recalcul. Cela peut améliorer considérablement les performances des fonctions coûteuses ou fréquemment appelées.

Exemple :

from functools import lru_cache

@lru_cache(maxsize=32)
def expensive_computation(x):
    return x ** 2

5 - @functools.wraps : Conserver les métadonnées dans les décorateurs personnalisés

Lors de l'écriture de décorateurs personnalisés, le décorateur @wraps préserve les métadonnées (nom, docstring) de la fonction d'origine, garantissant ainsi que les outils d'introspection fonctionnent toujours.

Exemple :

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        return func(*args, **kwargs)
    return wrapper

6 - @dataclass : Simplifier les définitions de classe

Le décorateur @dataclass (du module dataclasses) génère automatiquement des méthodes comme init() et repr() pour les classes. C’est parfait pour les cours détenant des données.

Exemple :

from dataclasses import dataclass

@dataclass
class Point:
    x: int
    y: int

Conclusion

Les décorateurs Python comme @staticmethod, @classmethod, @property, @lru_cache, @wraps et @dataclass aident à écrire du code plus propre et plus efficace en enveloppant les fonctionnalités autour des méthodes et des fonctions. Ce sont des outils polyvalents qui peuvent simplifier de nombreuses tâches de programmation.

Sources

Définition du décorateur Python
@staticmethod
@classmethod
@propriété
@functools.lru_cache
@functools.wraps
@dataclass

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!