Maîtriser les décorateurs Python : améliorer les fonctions avec des techniques expertes

Décorateurs Python

Les décorateurs vous permettent d'envelopper des fonctions avec une logique réutilisable, rendant votre code plus modulaire, lisible et maintenable. Dans ce guide, nous construisons, expliquons et appliquons des décorateurs dans des scénarios réels.

Vidéo : @Décorateurs en Python

Décorateurs en Python

Les décorateurs de Python sont un puissant outil de métaprogrammation qui permet d'ajouter du comportement à des fonctions ou classes au moment de la définition. Comme tout en Python est un objet — y compris les fonctions et les classes — les décorateurs opèrent en prenant un appelable, l'enveloppant dans un autre, et retournant le nouvel appelable.

---

Prérequis pour apprendre les décorateurs

Avant de plonger, vous devriez être à l'aise avec le fait qu'en Python, les fonctions sont des objets de première classe. Les noms sont simplement des références liées à des objets ; la même fonction peut être référencée par plusieurs noms.

def premier(msg):
    print(msg)
premier("Bonjour")
second = premier
second("Bonjour")

Sortie

Bonjour Bonjour

Les fonctions peuvent être passées comme arguments, retournées par d'autres fonctions, et même imbriquées dans d'autres fonctions. Ces concepts — fonctions d'ordre supérieur, fonctions imbriquées et fermetures — sont les blocs de construction des décorateurs.

def inc(x):
    return x + 1
def dec(x):
    return x - 1
def operer(func, x):
    resultat = func(x)
    return resultat

Utilisation :

>>> operer(inc, 3)
4
>>> operer(dec, 3)
2

def est_appelee():
    def est_retournee():
        print("Bonjour")
    return est_retournee
nouveau = est_appelee()
nouveau()

Sortie

Bonjour

Comprendre les fermetures est clé : la fonction imbriquée conserve l'accès à la portée englobante, ce que les décorateurs exploitent pour stocker des métadonnées ou modifier le comportement.

---

Revenons aux décorateurs

En Python, un décorateur est simplement un callable qui accepte une fonction (ou un autre callable) et retourne un nouveau callable. Cette fonction retournée enveloppe généralement l'originale, ajoutant ou modifiant la fonctionnalité avant ou après l'appel.

def rendre_joli(func):
    def interieur():
        print("J'ai été décoré")
        func()
    return interieur
def ordinaire():
    print("Je suis ordinaire")

Exemple d'utilisation :

>>> ordinaire()
Je suis ordinaire
>>> joli = rendre_joli(ordinaire)
>>> joli()
J'ai été décoré
Je suis ordinaire

Le motif décorateur garde la sémantique de la fonction originale intacte tout en l'augmentant. Pour éviter la réassignation manuelle, Python fournit du sucre syntaxique avec le symbole @ :

@rendre_joli
def ordinaire():
    print("Je suis ordinaire")

Ceci est équivalent à :

def ordinaire():
    print("Je suis ordinaire")
ordinaire = rendre_joli(ordinaire)

---

Décorer des fonctions avec paramètres

Beaucoup de décorateurs doivent gérer des arguments arbitraires. La syntaxe *args et **kwargs vous permet de capturer n'importe quels arguments positionnels ou nommés et de les transmettre inchangés.

def fonctionne_pour_tous(func):
    def interieur(*args, **kwargs):
        print("Je peux décorer n'importe quelle fonction")
        return func(*args, **kwargs)
    return interieur

La gestion des cas limites est un autre cas d'usage courant des décorateurs. Par exemple, se protéger contre la division par zéro :

def division_intelligente(func):
    def interieur(a, b):
        print("Je vais diviser", a, "et", b)
        if b == 0:
            print("Oups ! impossible de diviser")
            return
        return func(a, b)
    return interieur
@division_intelligente
def diviser(a, b):
    print(a/b)

Utilisation :

>>> diviser(2, 5)
Je vais diviser 2 et 5
0.4
>>> diviser(2, 0)
Je vais diviser 2 et 0
Oups ! impossible de diviser

---

Chaînage de décorateurs en Python

Les décorateurs peuvent être empilés. L'ordre d'application importe, car chaque décorateur reçoit la fonction retournée par celui du dessous.

def etoile(func):
    def interieur(*args, **kwargs):
        print("*" * 30)
        func(*args, **kwargs)
        print("*" * 30)
    return interieur
def pourcent(func):
    def interieur(*args, **kwargs):
        print("%" * 30)
        func(*args, **kwargs)
        print("%" * 30)
    return interieur
@etoile
@pourcent
def imprimante(msg):
    print(msg)

Résultat :

****************************** %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% Hello %%%%%%%%%%%%%%%%%%%%%%%%%%%%%% ******************************

Inverser l'ordre échange les motifs environnants, démontrant comment l'empilement de décorateurs influence le comportement.