Comment mesurer le temps d’exécution d’un script Python

Introduction à la mesure du temps d’exécution

Lorsque vous travaillez avec Python, il est courant de vouloir savoir combien de temps un script ou une fonction spécifique prend pour s’exécuter. C’est particulièrement important lorsque vous travaillez avec des tâches de traitement de données volumineuses ou des algorithmes complexes qui peuvent prendre beaucoup de temps à exécuter.

La mesure du temps d’exécution peut vous aider à identifier les parties de votre code qui sont particulièrement lentes et qui pourraient bénéficier d’une optimisation. De plus, cela peut être utile pour comparer les performances de différentes approches ou algorithmes pour résoudre un problème donné.

Dans cet article, nous allons explorer plusieurs méthodes pour mesurer le temps d’exécution en Python, y compris l’utilisation de modules intégrés comme timeit et datetime, ainsi que des techniques pour mesurer le temps d’exécution à partir de la ligne de commande. Nous discuterons également des différences entre certaines de ces méthodes et quand utiliser chacune d’elles.

Alors, commençons notre voyage dans la mesure du temps d’exécution en Python!

Utilisation du module timeit pour les petits extraits de code

Le module timeit est un outil intégré dans Python qui permet de mesurer le temps d’exécution de petits morceaux de code Python. Il a l’avantage d’offrir une précision élevée par rapport à d’autres méthodes et est particulièrement utile lorsque vous souhaitez comparer les performances de différentes approches pour un même problème.

Voici un exemple de base de l’utilisation de timeit :

import timeit

code_to_test = """
a = [1, 2, 3]
b = [x ** 2 for x in a]
"""

elapsed_time = timeit.timeit(code_to_test, number=1000)
print(f"Le code a pris {elapsed_time} secondes pour s'exécuter 1000 fois.")

Dans cet exemple, nous utilisons timeit.timeit() pour exécuter le code spécifié dans code_to_test 1000 fois. La fonction timeit() renvoie le temps en secondes que le code a pris pour s’exécuter le nombre de fois spécifié.

Il est important de noter que timeit désactive temporairement le garbage collector de Python, ce qui peut rendre son timing plus précis pour les petits bouts de code. Cependant, cela signifie aussi que timeit peut ne pas être précis pour les scripts plus longs qui peuvent être affectés par le garbage collector.

Dans la section suivante, nous explorerons comment mesurer le temps d’exécution d’un programme complet en Python.

Mesurer le temps d’exécution d’un programme complet en Python

Alors que timeit est idéal pour les petits extraits de code, vous voudrez peut-être mesurer le temps d’exécution d’un programme complet. Pour cela, vous pouvez utiliser le module time de Python.

Voici un exemple de base :

import time

start_time = time.time()

# Votre script ici
for i in range(0, 1000000):
    pass

end_time = time.time()

elapsed_time = end_time - start_time
print(f"Le programme a pris {elapsed_time} secondes pour s'exécuter.")

Dans cet exemple, nous utilisons time.time() pour obtenir le temps actuel avant et après l’exécution du script. En soustrayant le temps de début du temps de fin, nous obtenons le temps total d’exécution du script.

Il est important de noter que cette méthode mesure le temps en secondes depuis l’époque (habituellement le 1er janvier 1970), donc les valeurs retournées sont très grandes. Cependant, comme nous sommes intéressés par la différence entre deux points dans le temps plutôt que par le temps absolu, cela ne pose pas de problème.

Dans la section suivante, nous discuterons des différences entre time.time() et time.clock(), et quand utiliser chacun d’eux.

Différences entre time.time() et time.clock()

Il est important de noter que la fonction time.clock() a été supprimée depuis Python 3.3 et n’est plus disponible. À la place, Python a introduit deux nouvelles fonctions : time.perf_counter() et time.process_time().

Voici une brève description de ces fonctions :

• time.time() : Cette fonction renvoie le temps en secondes depuis l’époque, c’est-à-dire le 1er janvier 1970. Elle est généralement utilisée pour mesurer le temps d’exécution de blocs de code ou de programmes entiers.

• time.perf_counter() : Cette fonction renvoie le compteur de performance, c’est-à-dire le temps en secondes depuis un certain moment. Elle inclut le temps passé pendant le sommeil et est à résolution maximale. Elle est la meilleure option pour mesurer de petits laps de temps.

• time.process_time() : Cette fonction renvoie le temps de traitement du processeur en secondes depuis un certain moment. Elle n’inclut pas le temps passé pendant le sommeil. Elle est généralement utilisée pour mesurer le temps de traitement du processeur utilisé par un processus.

Il est recommandé d’utiliser time.perf_counter() pour la plupart des mesures de temps en Python, car elle fournit la résolution la plus élevée et inclut le temps passé pendant le sommeil.

Dans la section suivante, nous discuterons de l’utilisation de datetime pour le suivi du temps.

Utilisation de datetime pour le suivi du temps

Le module datetime de Python est un autre outil puissant pour travailler avec et manipuler le temps. Il est particulièrement utile pour le suivi du temps dans les applications en temps réel, où vous pourriez avoir besoin de marquer des événements avec le temps actuel.

Voici un exemple de base de l’utilisation de datetime pour le suivi du temps :

from datetime import datetime

start_time = datetime.now()

# Votre script ici
for i in range(0, 1000000):
    pass

end_time = datetime.now()

elapsed_time = end_time - start_time
print(f"Le programme a pris {elapsed_time} pour s'exécuter.")

Dans cet exemple, nous utilisons datetime.now() pour obtenir le temps actuel avant et après l’exécution du script. En soustrayant le temps de début du temps de fin, nous obtenons le temps total d’exécution du script.

Il est important de noter que datetime.now() renvoie un objet datetime qui contient à la fois la date et l’heure. Lorsque vous soustrayez deux objets datetime, vous obtenez un objet timedelta qui représente la différence entre les deux moments dans le temps.

Dans la section suivante, nous discuterons de la mesure du temps d’exécution à partir de la ligne de commande.

Mesurer le temps d’exécution à partir de la ligne de commande

Il est également possible de mesurer le temps d’exécution d’un script Python directement à partir de la ligne de commande. Cela peut être particulièrement utile si vous exécutez des scripts Python à partir d’un terminal ou dans un environnement sans tête.

Voici comment vous pouvez le faire :

1. Utilisation de la commande time : Sur les systèmes Unix (comme Linux ou Mac), vous pouvez utiliser la commande time pour mesurer le temps d’exécution d’un script Python. Par exemple :

time python your_script.py

Cette commande affiche le temps d’exécution réel (également appelé temps écoulé), le temps d’utilisation du processeur par l’utilisateur et le temps d’utilisation du processeur par le système.

1. Utilisation du module cProfile : Python fournit un module intégré appelé cProfile que vous pouvez utiliser pour profiler votre script Python et voir où il passe le plus de temps. Vous pouvez l’utiliser comme suit :

python -m cProfile your_script.py

Cela affiche une sortie détaillée montrant combien de temps a été passé dans chaque fonction de votre script.

Ces deux méthodes peuvent vous aider à comprendre où votre script Python passe le plus de temps, ce qui peut vous aider à identifier les parties de votre code qui pourraient bénéficier d’une optimisation. Dans la section suivante, nous conclurons et discuterons des meilleures pratiques pour mesurer le temps d’exécution en Python.

Conclusion et meilleures pratiques

Mesurer le temps d’exécution de votre code Python est une pratique essentielle pour l’optimisation des performances. Que vous travailliez avec de petits extraits de code ou des programmes complets, Python offre une variété d’outils pour vous aider à comprendre où votre code passe le plus de temps.

Voici quelques meilleures pratiques à garder à l’esprit :

• Utilisez timeit pour les petits extraits de code où vous voulez une mesure précise du temps d’exécution.
• Utilisez time.perf_counter() pour la plupart des mesures de temps en Python, car elle fournit la résolution la plus élevée et inclut le temps passé pendant le sommeil.
• Utilisez datetime pour le suivi du temps dans les applications en temps réel.
• N’oubliez pas que la mesure du temps d’exécution peut varier en fonction de nombreux facteurs, y compris la charge du système, donc il est toujours préférable de faire plusieurs mesures et de prendre une moyenne.
• Enfin, rappelez-vous que l’optimisation prématurée est la racine de tous les maux. Il est généralement préférable d’écrire d’abord un code clair et correct, puis de l’optimiser si nécessaire.

En suivant ces conseils, vous serez bien équipé pour mesurer et optimiser le temps d’exécution de votre code Python. Bonne programmation !