Que sont les décorateurs et comment en écrivez-vous un ?

Question

Accepted Answer

Un **décorateur** est une fonction qui **enveloppe une autre fonction** pour ajouter un comportement sans modifier le code original. Il s'applique avec la syntaxe `@decorator` au-dessus d'une fonction — un moyen propre d'ajouter des préoccupations transversales comme la journalisation, le timing, la mise en cache ou le contrôle d'accès.

## Comment fonctionnent les décorateurs

```python
def my_decorator(func):
    def wrapper(*args, **kwargs):       # wraps the original function
        print("before")
        result = func(*args, **kwargs)  # call the original
        print("after")
        return result
    return wrapper                       # return the wrapped version

@my_decorator
def greet(name):
    print(f"Hello {name}")

greet("Ann")
# Output: before / Hello Ann / after
```

La syntaxe `@my_decorator` est du sucre syntaxique pour `greet = my_decorator(greet)` — elle remplace `greet` par `wrapper`, qui exécute du code supplémentaire autour de l'appel original. `*args, **kwargs` permet au wrapper de fonctionner avec n'importe quelle signature de fonction.

## Un exemple pratique : timing

```python
import time, functools

def timed(func):
    @functools.wraps(func)        # preserves func's name/docstring (important!)
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        print(f"{func.__name__} took {time.perf_counter() - start:.3f}s")
        return result
    return wrapper

@timed
def slow_task():
    time.sleep(1)
```

`@functools.wraps(func)` est important — sans cela, la fonction enveloppée perd son nom original et sa docstring.

## Décorateurs avec arguments

```python
def repeat(times):               # outer takes the decorator's argument
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            for _ in range(times):
                func(*args, **kwargs)
        return wrapper
    return decorator

@repeat(times=3)
def hello(): print("hi")  # prints "hi" three times
```

Un décorateur paramétré nécessite une couche supplémentaire (une fonction qui retourne un décorateur).

## Décorateurs intégrés / de bibliothèque courants

```text
@property            → turn a method into a computed attribute
@staticmethod / @classmethod → method types
@functools.lru_cache → memoize results
@app.route("/")      → web framework routing (Flask)
@pytest.fixture      → test fixtures
```

## Pourquoi c'est important

Les décorateurs sont une fonctionnalité puissante et distinctement pythonique pour **ajouter un comportement réutilisable** (journalisation, timing, mise en cache, authentification, validation, routage) aux fonctions de manière propre et déclarative — en séparant les préoccupations transversales de la logique métier.

Ils sont partout dans le vrai Python : frameworks web (`@app.route`), mise en cache (`@lru_cache`), classes (`@property`) et tests.

Comprendre comment les écrire (une fonction wrapper, `*args/**kwargs`, `functools.wraps`) et la forme paramétrée vous permet d'utiliser correctement les décorateurs de l'écosystème et de créer vos propres abstractions réutilisables.