Exercice 95 / 100

Decorateurs

Cree un decorateur @timer qui mesure le temps d'execution. Teste avec une fonction qui calcule la somme des carres de 0 a 99999 et affiche le resultat.

Re-implémentation détaillée d'un décorateur @timer pour mesurer le temps d'exécution d'une fonction. Compagnon utile en data science pour profiler.

Rappel : structure d'un décorateur

def decorateur(func):
    def wrapper(*args, **kwargs):
        # avant
        result = func(*args, **kwargs)
        # après
        return result
    return wrapper

*args et **kwargs permettent au wrapper d'accepter n'importe quels arguments et de les transmettre à func.

@timer : implémentation

import time

def timer(func):
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        # On pourrait print(f'{func.__name__} a pris {elapsed:.4f}s')
        return result
    return wrapper

Lignes clés

time.time() horloge système en secondes (float, précision ms)

elapsed: durée de l'exécution
result: on conserve la valeur de retour de la fonction décorée

Un décorateur @timer pose une marque avant l'appel et une autre après : la durée mesurée est l'écart entre les deux, et la fonction décorée n'a rien à savoir de tout cela

Utilisation

@timer
def process_data(n):
    return sum(i ** 2 for i in range(n))

result = process_data(100000)
print(f'Résultat: {result}')

L'écriture @timer est équivalente à :

process_data = timer(process_data)

Version plus précise : perf_counter

Pour des mesures fines (sous-ms), préfère time.perf_counter() :

import time
start = time.perf_counter()
...
elapsed = time.perf_counter() - start    # bien plus précis

Garder le nom de la fonction

Sans précaution, la fonction décorée "perd" son nom (devient 'wrapper'). Pour préserver :

from functools import wraps

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

Maintenant process_data.__name__ vaut bien 'process_data'.

Profilage plus avancé

Pour du profilage sérieux :

- %timeit dans Jupyter
- module cProfile (analyse appel par appel)
- lib externe : line_profiler (ligne par ligne)

Un décorateur @timer collé sur quelques fonctions critiques permet de repérer rapidement les goulots d'étranglement d'un script.

exercise.py