Établir une mesure reproductible

Un script qui semble lent ne vous indique pas, à lui seul, combien de temps prend son traitement métier. Pour comparer deux versions, vous devez leur fournir les mêmes dépenses et répéter les mesures dans des conditions comparables. Vous établirez ici une référence simple avant d’examiner les fonctions coûteuses dans la prochaine leçon.

Préparer un scénario mesurable

Le scénario doit être assez précis pour être rejoué : même fonction, même nombre de dépenses et mêmes montants. Le script ci-dessous construit une liste déterministe de 10 000 dépenses, puis additionne leurs montants. La génération des données est séparée du traitement chronométré afin que la mesure porte sur l’agrégation, et non sur la création de la liste.

from statistics import median
from timeit import repeat


Depense = tuple[str, float]


def totaliser(depenses: list[Depense]) -> float:
    """Retourne la somme des montants des dépenses."""
    return sum(montant for _, montant in depenses)


def creer_jeu_depenses(nombre: int) -> list[Depense]:
    """Construit toujours le même jeu de données pour un nombre donné."""
    return [
        (f"Dépense {index}", (index % 500) / 100 + 1.0)
        for index in range(nombre)
    ]


def main() -> None:
    depenses = creer_jeu_depenses(10_000)

    repetitions = repeat(
        stmt="totaliser(depenses)",
        globals={"totaliser": totaliser, "depenses": depenses},
        number=1_000,
        repeat=7,
    )
    temps_par_execution = [temps / 1_000 for temps in repetitions]

    print(f"Nombre de dépenses : {len(depenses)}")
    print(f"Exécutions par mesure : 1 000")
    print(f"Mesures : {len(temps_par_execution)}")
    print(f"Médiane : {median(temps_par_execution):.8f} s par exécution")


if __name__ == "__main__":
    main()

Exemple de forme de sortie ; la durée varie selon la machine :
Nombre de dépenses : 10000
Exécutions par mesure : 1 000
Mesures : 7
Médiane : 0.0004xxxx s par exécution

La fonction repeat exécute le même appel 1 000 fois, puis recommence ce lot sept fois. Chaque durée totale est divisée par 1 000 pour obtenir une durée moyenne par appel dans ce lot. L’utilisation de globals rend les noms nécessaires disponibles à l’instruction mesurée, sans reconstruire la liste à chaque exécution.

Lancer et interpréter la mesure

Depuis la racine du projet, lancez python scripts/profiler.py. Le script affiche le nombre d’éléments et de répétitions, puis une durée médiane par appel. Le chiffre exact dépend de votre matériel, de la version de Python et de la charge de la machine : la sortie attendue est donc une structure de résultat, pas une valeur universelle à reproduire.

La médiane est la valeur centrale des durées une fois celles-ci ordonnées. Elle réduit l’influence d’une mesure anormalement haute ou basse, sans rendre les résultats indépendants de l’environnement. Conservez donc aussi les paramètres du scénario avec la valeur obtenue : « 10 000 dépenses, 1 000 appels par mesure, 7 mesures » est une référence plus utile qu’un temps seul.

Ce benchmark mesure précisément l’addition de montants pour cette fonction et ces données. Il ne mesure ni les entrées-sorties asynchrones de la collecte, ni le temps de démarrage du processus, ni le comportement de tout l’outil. Avant d’en tirer une conclusion, vérifiez que le scénario représente bien l’opération que vous cherchez à comparer. Cette discipline évite d’optimiser une partie qui n’est pas en cause.

À retenir

• Définissez une opération précise et un jeu de dépenses déterministe.
• Séparez la préparation des données du code chronométré.
• Répétez les mesures avec timeit et ramenez les durées au temps par appel.
• Utilisez la médiane et conservez les paramètres du scénario pour rendre la comparaison exploitable.

Dans la prochaine leçon, vous utiliserez cProfile pour repérer les fonctions qui contribuent le plus au temps d’exécution.