Un décorateur Python est une fonction qui prend une autre fonction et en renvoie une version modifiée, sans toucher au code de la fonction d’origine. Il permet d’ajouter un comportement (mesurer le temps, afficher les arguments, mettre en cache, réessayer après une erreur) avec une seule ligne : @nom_du_decorateur.
Dans ce guide, je t’explique comment fonctionne un décorateur, puis je te montre 7 exemples utiles : @timer, @wraps, @debug, @memoize (et son remplaçant @cache), @retry avec arguments, l’empilement de décorateurs et les décorateurs intégrés. Chaque exemple est exécuté, avec sa vraie sortie.
Article mis à jour en novembre 2026 : j’ai exécuté tout le code avec Python 3.13. J’ai remplacé time.time() par time.perf_counter() (plus précis pour les durées courtes), ajouté la démonstration chiffrée du cache (2 692 537 appels réduits à 31), les limites de @memoize (arguments nommés, listes), le décorateur @retry avec arguments et l’ordre d’empilement. J’ai aussi retiré la promesse de « réduire ton code de moitié » : un décorateur supprime les répétitions, pas le code en général.
En bref : @decorateur au-dessus d’une fonction équivaut à f = decorateur(f). Ajoute toujours @wraps(func) dans ton décorateur pour garder le nom et la docstring de la fonction. Utilise *args, **kwargs pour qu’il marche avec n’importe quelle fonction. Pour un cache, préfère functools.cache à un memoize maison. Pour un décorateur qui prend des paramètres, ajoute une fonction englobante (@retry(fois=3)). Plusieurs décorateurs s’appliquent de bas en haut.
Tu peux exécuter tout le code de cet article dans ce notebook Google Colab : il n’utilise que la bibliothèque standard de Python, il n’y a rien à installer ni à télécharger.

Qu’est-ce qu’un décorateur Python ?
Un décorateur est une fonction qui reçoit une fonction et renvoie une nouvelle fonction qui l’enveloppe. Prenons une fonction très simple, et ajoutons-lui la mesure de son temps d’exécution sans modifier son code :
import time
def hello():
print("Hello world !")
def measure_time(func):
def wrapper():
debut = time.perf_counter()
func()
fin = time.perf_counter()
print(f"Durée d'exécution : {fin - debut:.6f} secondes")
return wrapper
hello = measure_time(hello)
hello()PythonHello world !
Durée d'exécution : 0.000008 secondesNous avons écrit hello = measure_time(hello) : la fonction measure_time renvoie wrapper, qui note l’heure, appelle la fonction d’origine, note l’heure à nouveau et affiche la durée. La durée affichée est de quelques microsecondes : elle change à chaque exécution.
Python offre une syntaxe plus lisible : le symbole @. Placer @measure_time au-dessus d’une fonction revient exactement à écrire bonjour = measure_time(bonjour) après sa définition :
@measure_time
def bonjour():
print("Bonjour !")
bonjour()
print(bonjour.__name__)PythonBonjour !
Durée d'exécution : 0.000002 secondes
wrapperRemarque la dernière ligne : le nom de la fonction décorée est maintenant wrapper, pas bonjour. Nous corrigerons cela plus bas avec functools.wraps.
Pourquoi utiliser des décorateurs Python ?
- Éviter les répétitions : si dix fonctions doivent mesurer leur durée, un seul décorateur remplace dix copies du même code.
- Séparer les responsabilités : le logging, le cache, la validation ou la gestion d’erreurs restent hors de la logique de la fonction.
- Étendre du code existant : tu peux envelopper une fonction d’une bibliothèque tierce sans la modifier.
Attention : le gain dépend de la répétition. Un décorateur utilisé pour une seule fonction n’allège rien, il ajoute même une couche à lire. L’intérêt apparaît dès que la même logique sert plusieurs fois.
Comment écrire un décorateur @timer pour n’importe quelle fonction ?
Le décorateur précédent ne marche que pour une fonction sans argument. Pour qu’il s’applique à toute fonction, le wrapper reçoit *args, **kwargs (tous les arguments, positionnels et nommés) et renvoie le résultat de la fonction. J’utilise time.perf_counter(), plus précis que time.time() pour mesurer des durées courtes :
from functools import wraps
def timer(func):
@wraps(func)
def wrapper(*args, **kwargs):
debut = time.perf_counter()
resultat = func(*args, **kwargs)
duree = time.perf_counter() - debut
print(f"{func.__name__} : {duree * 1000:.1f} ms")
return resultat
return wrapper
@timer
def somme_carres(n):
"""Renvoie la somme des carrés des entiers de 0 à n - 1"""
return sum(i ** 2 for i in range(n))
print(somme_carres(1_000_000))Pythonsomme_carres : 47.1 ms
333332833333500000Le résultat est bien renvoyé (333 332 833 333 500 000), et la durée s’affiche : environ 50 ms sur ma machine. Elle varie d’une exécution à l’autre, donc mesure plusieurs fois avant de conclure. Pour comparer sérieusement deux versions d’un code, tu peux aussi utiliser le module timeit.
Pourquoi ajouter functools.wraps dans un décorateur ?
Sans précaution, la fonction décorée perd son identité : son nom devient wrapper et sa docstring disparaît, ce qui gêne le débogage, la documentation et les outils qui lisent ces informations. Le décorateur @wraps(func) recopie le nom, la docstring et d’autres attributs de la fonction d’origine :
def sans_wraps(func):
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper
def avec_wraps(func):
@wraps(func)
def wrapper(*args, **kwargs):
return func(*args, **kwargs)
return wrapper
@sans_wraps
def f1():
"""Docstring de f1"""
@avec_wraps
def f2():
"""Docstring de f2"""
print("Sans wraps :", f1.__name__, "|", f1.__doc__)
print("Avec wraps :", f2.__name__, "|", f2.__doc__)PythonSans wraps : wrapper | None
Avec wraps : f2 | Docstring de f2Sans wraps, on obtient wrapper et None. Avec wraps, la fonction garde son nom et sa docstring. Ajoute-le systématiquement dans tes décorateurs.
Comment écrire un décorateur @debug ?
Le décorateur @debug affiche le nom de la fonction, ses arguments et sa valeur de retour. Il est pratique pour comprendre ce qui se passe sans placer des print partout :
def debug(func):
@wraps(func)
def wrapper(*args, **kwargs):
print(f"Appel de {func.__name__} avec les arguments : {args} et les kwargs : {kwargs}")
resultat = func(*args, **kwargs)
print(f"{func.__name__} renvoie : {resultat}")
return resultat
return wrapper
@debug
def add(x, y):
"""Renvoie la somme de x et y"""
return x + y
@debug
def greet(name, message="Hello"):
"""Renvoie un message d'accueil avec le nom"""
return f"{message} {name}!"
print(add(2, 3))
print(greet("Alice"))
print(greet("Bob", message="Salut"))PythonAppel de add avec les arguments : (2, 3) et les kwargs : {}
add renvoie : 5
5
Appel de greet avec les arguments : ('Alice',) et les kwargs : {}
greet renvoie : Hello Alice!
Hello Alice!
Appel de greet avec les arguments : ('Bob',) et les kwargs : {'message': 'Salut'}
greet renvoie : Salut Bob!
Salut Bob!Chaque appel est tracé avec ses arguments positionnels (le tuple) et nommés (le dictionnaire). Pour un vrai projet, remplace print par le module logging, qui gère les niveaux de message et les fichiers de log.
Comment mettre en cache les résultats avec @memoize ?
La mémoïsation consiste à stocker le résultat d’un appel pour ne pas le recalculer quand les mêmes arguments reviennent. L’exemple classique est la suite de Fibonacci écrite de façon récursive. Voici d’abord la version sans cache, avec un compteur d’appels :
appels = 0
def fib_naif(n):
global appels
appels += 1
if n < 2:
return n
return fib_naif(n - 1) + fib_naif(n - 2)
debut = time.perf_counter()
resultat = fib_naif(30)
duree = time.perf_counter() - debut
print(resultat, "en", f"{appels:,}".replace(",", " "), "appels")
print(f"Durée : {duree:.2f} s")Python832040 en 2 692 537 appels
Durée : 0.14 sPour calculer le 30e nombre de Fibonacci, la fonction s’appelle 2 692 537 fois, car elle recalcule sans cesse les mêmes valeurs. Voici le décorateur @memoize, qui garde un dictionnaire de résultats :
def memoize(func):
cache = {}
@wraps(func)
def wrapper(*args):
if args not in cache:
cache[args] = func(*args)
return cache[args]
return wrapper
appels_memo = 0
@memoize
def fib(n):
global appels_memo
appels_memo += 1
if n < 2:
return n
return fib(n - 1) + fib(n - 2)
print(fib(30), "en", appels_memo, "appels")
print(fib(100))Python832040 en 31 appels
354224848179261915075Même résultat (832 040), mais en 31 appels au lieu de 2 692 537. Et on peut maintenant calculer fib(100), ce qui est hors de portée de la version naïve. Le gain est spectaculaire, mais il vient d’un cas particulier : une fonction qui refait les mêmes calculs.
Quelles sont les limites d’un memoize fait maison ?
Ce décorateur simple ne gère pas les arguments nommés et ne marche qu’avec des arguments « hashables » (donc pas de liste ni de dictionnaire). Son cache grandit aussi sans limite. Voici les erreurs :
def essayer(f):
try:
print(f())
except Exception as e:
print(type(e).__name__, ":", e)
essayer(lambda: fib(n=10))
essayer(lambda: memoize(sum)([1, 2, 3]))PythonTypeError : fib() got an unexpected keyword argument 'n'
TypeError : unhashable type: 'list'Python fournit déjà ce mécanisme dans functools : @cache (Python 3.9 et plus, cache sans limite) et @lru_cache(maxsize=...) (cache limité, qui supprime les entrées les moins récemment utilisées). Ils gèrent les arguments nommés et exposent des statistiques :
from functools import cache
@cache
def fib_c(n):
return n if n < 2 else fib_c(n - 1) + fib_c(n - 2)
print(fib_c(30))
print(fib_c.cache_info())
print(fib_c(n=10))Python832040
CacheInfo(hits=28, misses=31, maxsize=None, currsize=31)
55cache_info() indique 31 calculs (misses) et 28 réutilisations (hits). L’appel avec un argument nommé fib_c(n=10) fonctionne aussi. Les arguments doivent rester hashables, et un cache sans limite peut occuper beaucoup de mémoire : sur un long programme, choisis lru_cache avec une taille maximale.
Comment créer un décorateur qui prend des arguments ?
Pour écrire @retry(fois=3), il faut une fonction de plus : la première reçoit les paramètres du décorateur, la deuxième reçoit la fonction, la troisième est le wrapper. Voici un décorateur qui réessaie un appel instable :
def retry(fois=3):
def decorateur(func):
@wraps(func)
def wrapper(*args, **kwargs):
for essai in range(1, fois + 1):
try:
return func(*args, **kwargs)
except Exception as e:
print(f"Essai {essai}/{fois} échoué : {e}")
raise RuntimeError(f"{func.__name__} a échoué {fois} fois")
return wrapper
return decorateur
etat = {"appels": 0}
@retry(fois=3)
def appel_instable():
etat["appels"] += 1
if etat["appels"] < 3:
raise ConnectionError("serveur indisponible")
return "OK"
print(appel_instable())PythonEssai 1/3 échoué : serveur indisponible
Essai 2/3 échoué : serveur indisponible
OKLes deux premiers essais échouent, le troisième réussit, et le résultat est renvoyé. Si tous les essais échouent, le décorateur lève une erreur :
@retry(fois=2)
def toujours_en_panne():
raise ValueError("données invalides")
essayer(toujours_en_panne)PythonEssai 1/2 échoué : données invalides
Essai 2/2 échoué : données invalides
RuntimeError : toujours_en_panne a échoué 2 foisDans un vrai programme, ne réessaie que les erreurs temporaires (réseau, délai dépassé), jamais les erreurs de logique, et ajoute une pause entre les essais.
Dans quel ordre s’appliquent plusieurs décorateurs ?
Quand tu empiles plusieurs décorateurs, celui qui est le plus proche de la fonction s’applique en premier. Le code @A @B def f équivaut à f = A(B(f)). Voici ce que cela donne à l’exécution :
def etiquette(nom):
def deco(func):
@wraps(func)
def wrapper(*args, **kwargs):
print("entrée", nom)
resultat = func(*args, **kwargs)
print("sortie", nom)
return resultat
return wrapper
return deco
@etiquette("A")
@etiquette("B")
def travail():
print("travail")
travail()Pythonentrée A
entrée B
travail
sortie B
sortie ALe décorateur A est le plus externe : il entre en premier et sort en dernier. L’ordre compte : un @timer placé au-dessus d’un @cache mesure aussi les appels servis par le cache, alors que placé en dessous, il ne mesure que les vrais calculs.
Quels sont les décorateurs intégrés à Python ?
Tu utilises déjà des décorateurs sans le savoir : @property transforme une méthode en attribut calculé, @staticmethod et @classmethod définissent des méthodes qui ne dépendent pas d’une instance, et @dataclass (décorateur de classe) génère automatiquement __init__, __repr__ et __eq__ :
from dataclasses import dataclass
class Temperature:
def __init__(self, celsius):
self._c = celsius
@property
def fahrenheit(self):
return self._c * 9 / 5 + 32
@staticmethod
def est_valide(celsius):
return celsius >= -273.15
@classmethod
def depuis_fahrenheit(cls, f):
return cls((f - 32) * 5 / 9)
t = Temperature(25)
print(t.fahrenheit)
print(Temperature.est_valide(-300))
print(Temperature.depuis_fahrenheit(212)._c)
@dataclass
class Point:
x: int
y: int
print(Point(1, 2), Point(1, 2) == Point(1, 2))Python77.0
False
100.0
Point(x=1, y=2) TrueLes décorateurs fonctionnent donc aussi sur les classes. Pour aller plus loin dans la programmation orientée objet, lis ce guide sur la POO en Python.
Questions fréquentes
Qu’est-ce qu’un décorateur en Python ?
C’est une fonction qui prend une fonction en argument et renvoie une nouvelle fonction qui l’enveloppe, pour ajouter un comportement sans modifier le code d’origine. La syntaxe @decorateur au-dessus d’une fonction équivaut à f = decorateur(f).
À quoi sert functools.wraps dans un décorateur ?
Il recopie le nom, la docstring et d’autres attributs de la fonction d’origine sur le wrapper. Sans lui, la fonction décorée s’appelle wrapper et perd sa docstring, ce qui gêne le débogage et la documentation.
Quelle est la différence entre @cache et @lru_cache ?
@cache (Python 3.9 et plus) garde tous les résultats sans limite. @lru_cache(maxsize=n) garde les n résultats les plus récents et supprime les autres, ce qui évite de saturer la mémoire.
Comment faire un décorateur avec des arguments ?
Ajoute une fonction englobante : la première reçoit les arguments du décorateur (par exemple fois=3), la deuxième reçoit la fonction à décorer, la troisième est le wrapper. On l’utilise ensuite avec @retry(fois=3).
Dans quel ordre s’exécutent des décorateurs empilés ?
Ils s’appliquent de bas en haut : celui qui est le plus proche de la fonction l’enveloppe en premier. À l’appel, le décorateur le plus externe entre en premier et sort en dernier.
Les décorateurs ralentissent-ils le code ?
Un peu : chaque appel passe par le wrapper, ce qui ajoute un appel de fonction. Cette surcharge est négligeable pour la plupart des usages, mais à surveiller dans une boucle très serrée. Un cache bien placé peut au contraire accélérer fortement une fonction.
Pour t’entraîner, parcours aussi mes 25 extraits de code Python de référence pour ton travail quotidien.
Conclusion : quand utiliser un décorateur ?
Utilise un décorateur quand une même logique (mesure de temps, cache, trace, nouvelle tentative, contrôle d’accès) s’applique à plusieurs fonctions. Écris-le avec *args, **kwargs et @wraps, et regarde d’abord ce que propose la bibliothèque standard (functools.cache, lru_cache, dataclass) avant d’écrire le tien.
Pour progresser en Python, le mieux est de pratiquer. Sur DataXp, tu apprends Python et la data science avec des exercices pratiques à faire directement en ligne.
Pour retrouver l’essentiel d’un coup d’œil, consulte aussi nos astuces et concepts Python pour améliorer ton code.
Pour aller plus loin, voici d’autres articles qui pourraient te plaire :













