Table des matières
- Utilisation de
time.time() - Utilisation de
time.process_time() - Utilisation de
time.perf_counter() - Utilisation de
time.monotonic()
Le module time de Python fournit plusieurs fonctions pour mesurer le temps écoulé, chacune ayant ses propres forces et faiblesses. Le choix optimal dépend de l’application spécifique et du niveau de précision requis. Cet article clarifie les distinctions entre quatre fonctions de minuterie clés : time.time(), time.process_time(), time.perf_counter() et time.monotonic().
Utilisation de time.time()
time.time() renvoie l’heure système actuelle sous forme de nombre à virgule flottante représentant les secondes écoulées depuis l’époque (généralement le 1er janvier 1970, 00:00:00 UTC). Il s’agit d’une heure « horloge murale », susceptible de modifications dues aux ajustements de l’horloge système (par exemple, synchronisation NTP). Par conséquent, elle ne convient pas aux mesures de temps précises.
import time
start_time = time.time()
# ... du code à chronométrer ...
end_time = time.time()
elapsed_time = end_time - start_time
print(f"Temps écoulé : {elapsed_time:.4f} secondes")
Utilisez time.time() pour les applications ne nécessitant qu’une estimation approximative du temps écoulé, telles que la journalisation des heures de début et de fin d’un processus.
Utilisation de time.process_time()
time.process_time() mesure la somme du temps CPU système et utilisateur du processus courant, à l’exclusion du temps passé en veille ou en attente d’E/S. Il est idéal pour l’évaluation comparative des opérations liées au processeur, fournissant une mesure fiable du temps CPU consommé. Il n’est pas affecté par les changements d’horloge système et ne représente pas le temps de l’horloge murale.
import time
start_time = time.process_time()
# ... du code lié au processeur ...
end_time = time.process_time()
elapsed_time = end_time - start_time
print(f"Temps de processus écoulé : {elapsed_time:.4f} secondes")
Cette fonction est la mieux adaptée pour évaluer l’effort de calcul d’un programme, indépendamment des facteurs externes.
Utilisation de time.perf_counter()
time.perf_counter() fournit une valeur de compteur de performance haute résolution avec la précision la plus élevée disponible. Il est parfait pour l’évaluation comparative du code où la précision est primordiale. Comme time.process_time(), il n’est pas affecté par les ajustements de l’horloge système, mais contrairement à time.process_time(), il inclut le temps passé en veille ou en attente.
import time
start_time = time.perf_counter()
# ... du code à chronométrer précisément ...
end_time = time.perf_counter()
elapsed_time = end_time - start_time
print(f"Temps du compteur de performance écoulé : {elapsed_time:.6f} secondes")
Utilisez time.perf_counter() pour les micro-évaluations comparatives et les applications nécessitant des mesures de temps extrêmement précises, indépendamment des changements d’horloge système.
Utilisation de time.monotonic()
time.monotonic() renvoie une valeur de compteur croissant de manière monotone. La valeur augmente toujours et n’est jamais diminuée, même avec des ajustements de l’horloge système. Elle est essentielle pour mesurer le temps écoulé lorsqu’il est crucial de garantir une valeur temporelle toujours croissante, indépendamment des influences externes. Elle n’est pas directement liée au temps de l’horloge murale ou au temps CPU.
import time
start_time = time.monotonic()
# ... du code ...
end_time = time.monotonic()
elapsed_time = end_time - start_time
print(f"Temps monotone écoulé : {elapsed_time:.4f} secondes")
Cette fonction est essentielle dans les scénarios où les ajustements d’horloge pourraient entraîner des mesures de temps inexactes, telles que les boucles de jeu ou les barres de progression.
En conclusion, le choix de la fonction de minuterie appropriée dépend entièrement des besoins de l’application spécifique. Pour une mesure générale du temps, time.time() peut suffire. Pour les tâches liées au processeur, time.process_time() est recommandé. Pour les mesures de haute précision, time.perf_counter() est idéal. Enfin, time.monotonic() garantit des valeurs temporelles croissantes de manière monotone, ce qui est crucial lorsque les ajustements d’horloge sont un problème.