Les décorateurs Python sont une fonctionnalité élégante et puissante qui permet aux développeurs de modifier ou d'améliorer le comportement des fonctions ou des méthodes sans changer leur code. Souvent sous-utilisés, les décorateurs peuvent rendre votre code plus concis, réutilisable et maintenable. Dans cet article, nous allons explorer le concept de décorateurs, leurs cas d'utilisation pratiques et plonger dans des techniques avancées telles que la création de décorateurs paramétrés, l'empilement de plusieurs décorateurs et la mise en œuvre d'une programmation orientée aspect.

Que sont les décorateurs ?

Les décorateurs en Python sont essentiellement des fonctions d'ordre supérieur qui prennent une fonction en entrée et renvoient une nouvelle fonction avec un comportement supplémentaire ou modifié. Ils sont définis à l'aide du symbole '@' suivi du nom de la fonction décoratrice placé au-dessus de la définition de la fonction cible.

Utilisation de base

Commençons par créer un décorateur simple qui mesure le temps d'exécution d'une fonction :

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:.2f} seconds to execute.")
        return result

    return wrapper

@timer_decorator
def slow_function():
    time.sleep(2)

slow_function()

slow_function took 2.00 seconds to execute.

1. Journalisation et débogage : les décorateurs peuvent être utilisés pour consigner des informations sur les appels de fonction, telles que les arguments d'entrée, les valeurs de retour et le temps d'exécution.
2. Autorisation et contrôle d'accès : vous pouvez créer des décorateurs pour vérifier les rôles, les autorisations ou l'authentification des utilisateurs avant d'autoriser l'accès à une fonction ou à une méthode spécifique. ( Exemple : sur le framework Django comme raccourci, vous pouvez utiliser le décorateur pratique login_required() )
3. Mise en cache et mémorisation : les décorateurs peuvent stocker les résultats d'appels de fonctions coûteux, évitant ainsi les calculs redondants et améliorant les performances.

1. Décorateurs paramétrés : ces décorateurs acceptent des arguments qui peuvent être utilisés pour personnaliser leur comportement. Pour créer un décorateur paramétré, définissez une fonction externe qui prend les paramètres souhaités et renvoie la fonction de décorateur réelle.

def retry_decorator(max_retries):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for i in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    print(f"Attempt {i + 1} failed with error: {e}")
            raise Exception("All attempts failed")

        return wrapper
    return decorator


@retry_decorator(max_retries=3)
def unreliable_function():
    """
    Let's assume that we have made an incorrect operation, for example; 
    ZeroDivisionError is a built-in Python exception thrown when a 
    number is divided by 0
    """
    print(100/0)


unreliable_function()

Attempt 1 failed with error: division by zero
Attempt 2 failed with error: division by zero
Attempt 3 failed with error: division by zero
Traceback (most recent call last):
  File "/Users/aliyaman/Desktop/main.py", line 24, in <module>
    unreliable_function()
  File "/Users/aliyaman/Desktop/main.py", line 9, in wrapper
    raise Exception("All attempts failed")
Exception: All attempts failed

@decorator1
@decorator2
def my_function():
    pass

Les décorateurs sont des outils puissants, mais ils peuvent aussi être une source de confusion et d'erreurs s'ils ne sont pas utilisés correctement. En comprenant les pièges courants et les meilleures pratiques associées aux décorateurs, vous pouvez éviter ces problèmes et écrire un code Python plus efficace.

1. Oublier d'appeler la fonction enveloppée : Une erreur courante est d'oublier d'appeler la fonction enveloppée dans le décorateur. Assurez-vous d'appeler la fonction d'origine avec les arguments nécessaires (*args et **kwargs) dans la fonction wrapper du décorateur.
2. Ne pas renvoyer le résultat : Renvoyez toujours le résultat de l'appel de fonction d'origine à partir de la fonction wrapper, sauf si vous souhaitez intentionnellement supprimer ou modifier la valeur de retour.
3. Perte de métadonnées de fonction : lors de l'utilisation de décorateurs, des métadonnées importantes telles que le nom de la fonction, la chaîne de documentation et les annotations peuvent être perdues. Utilisez la functools.wrapsfonction pour conserver ces informations en ajoutant @functools.wraps(func)immédiatement avant de définir la fonction wrapper dans le décorateur :

import functools

def my_decorator(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        # Decorator logic here
        return func(*args, **kwargs)
    return wrapper

Décorateurs intégrés

Les décorateurs intégrés de Python offrent aux développeurs un moyen pratique de modifier le comportement des fonctions et des méthodes sans changer leur code. Ces décorateurs peuvent aider à rendre votre code plus efficace, maintenable et lisible. Dans cet article, nous aborderons trois décorateurs intégrés couramment utilisés en Python : @staticmethod , @classmethod et @property . Nous couvrirons leurs cas d'utilisation et fournirons des exemples pour démontrer leurs applications pratiques.

1. Le décorateur @staticmethod est utilisé pour définir des méthodes statiques au sein d'une classe. Une méthode statique est une méthode qui appartient à la classe plutôt qu'à une instance de la classe, et elle ne nécessite pas l'appel d'une instance. Cela signifie que les méthodes statiques ne peuvent pas accéder ou modifier les attributs ou méthodes spécifiques à l'instance.

class MathOperations:
    @staticmethod
    def add(a, b):
        return a + b

result = MathOperations.add(5, 3)
print(result)  # Output: 8

Les méthodes de classe sont utiles lorsque vous souhaitez créer des méthodes de fabrique ou effectuer des actions qui dépendent de l'état de la classe plutôt que de l'état de l'instance.

class Employee:
    _id = 0

    def __init__(self, name):
        self.name = name
        self.id = Employee._id
        Employee._id += 1

    @classmethod
    def get_next_id(cls):
        return cls._id

employee1 = Employee("Alice")
employee2 = Employee("Bob")
print(Employee.get_next_id())  # Output: 2

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

    @property
    def radius(self):
        return self._radius

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

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

circle = Circle(5)
print(circle.radius)    # Output: 5
print(circle.diameter)  # Output: 10
print(circle.area)      # Output: 78.53975

En conclusion, les décorateurs Python sont un outil puissant qui vous permet de modifier ou d'améliorer le comportement des fonctions et des méthodes de manière propre et réutilisable. Comprendre les décorateurs et leurs techniques avancées peut grandement améliorer vos compétences en programmation Python et vous aider à écrire un code plus efficace et maintenable. N'hésitez pas à explorer l'univers des décorateurs et à valoriser leur potentiel dans vos projets !