Mesurer le temps écoulé avec le module Time
Avec le module Time dans python, est-il possible de mesurer le temps écoulé? Si oui, comment je fais ça?
Je dois le faire pour que, si le curseur est dans un widget depuis un certain temps, un événement se produise.
start_time = time.time()
# your code
elapsed_time = time.time() - start_time
Vous pouvez également écrire simple décorator pour simplifier la mesure du temps d'exécution de diverses fonctions:
import time
from functools import wraps
PROF_DATA = {}
def profile(fn):
@wraps(fn)
def with_profiling(*args, **kwargs):
start_time = time.time()
ret = fn(*args, **kwargs)
elapsed_time = time.time() - start_time
if fn.__not in PROF_DATA:
PROF_DATA[fn.__name__] = [0, []]
PROF_DATA[fn.__name__][0] += 1
PROF_DATA[fn.__name__][1].append(elapsed_time)
return ret
return with_profiling
def print_prof_data():
for fname, data in PROF_DATA.items():
max_time = max(data[1])
avg_time = sum(data[1]) / len(data[1])
print "Function %s called %d times. " % (fname, data[0]),
print 'Execution time max: %.3f, average: %.3f' % (max_time, avg_time)
def clear_prof_data():
global PROF_DATA
PROF_DATA = {}
Usage:
@profile
def your_function(...):
...
Vous pouvez profiler plusieurs fonctions simultanément. Ensuite, pour imprimer les mesures, appelez simplement print_prof_data ():
time.time() fera le travail.
import time
start = time.time()
# run your code
end = time.time()
elapsed = end - start
Vous voudrez peut-être regarder this question, mais je ne pense pas que ce sera nécessaire.
Pour les utilisateurs qui veulent une meilleure mise en forme,
import time
start_time = time.time()
# your script
elapsed_time = time.time() - start_time
time.strftime("%H:%M:%S", time.gmtime(elapsed_time))
imprimera pendant 2 secondes:
'00:00:02'
et pendant 7 minutes une seconde:
'00:07:01'
notez que l'unité de temps minimale avec gmtime est secondes. Si vous avez besoin de microsecondes, tenez compte des points suivants:
import datetime
start = datetime.datetime.now()
# some code
end = datetime.datetime.now()
elapsed = end - start
print(elapsed)
# or
print(elapsed.seconds,":",elapsed.microseconds)
strftime documentation
Pour obtenir la meilleure mesure du temps écoulé (depuis Python 3.3), utilisez time.perf_counter() .
Renvoie la valeur (en quelques fractions de secondes) d’un compteur de performance, c’est-à-dire une horloge avec la résolution disponible la plus élevée possible pour mesurer une courte durée. Cela inclut le temps écoulé pendant le sommeil et concerne l'ensemble du système. Le point de référence de la valeur renvoyée est indéfini, de sorte que seule la différence entre les résultats d'appels consécutifs est valide.
Pour les mesures de l'ordre des heures/jours, la résolution inférieure à la seconde vous importe peu, utilisez donc time.monotonic() .
Renvoie la valeur (en quelques fractions de secondes) d’une horloge monotone, c’est-à-dire une horloge qui ne peut pas revenir en arrière. L'horloge n'est pas affectée par les mises à jour de l'horloge système. Le point de référence de la valeur renvoyée est indéfini, de sorte que seule la différence entre les résultats d'appels consécutifs est valide.
Dans de nombreuses applications, il peut en réalité s'agir de la même chose.
Avant la version 3.3, vous êtes coincé avec time.clock() .
Sous Unix, renvoyez le temps processeur actuel sous forme de nombre à virgule flottante exprimé en secondes. La précision, et en fait la définition même de la signification de "temps processeur", dépend de celle de la fonction C du même nom.
Sous Windows, cette fonction renvoie le nombre de secondes écoulées depuis le premier appel de cette fonction sous forme de nombre à virgule flottante, basé sur la fonction Win32 QueryPerformanceCounter (). La résolution est généralement meilleure qu'une microseconde.
Mise à jour pour Python 3.7
La nouveauté dans Python 3.7 est PEP 564 - Ajoute de nouvelles fonctions de temps avec une résolution en nanosecondes.
Leur utilisation permet d’éliminer davantage les erreurs d’arrondi et de virgule flottante, en particulier si vous mesurez de très courtes périodes, ou si votre application (ou votre machine Windows) est longue.
La résolution commence à s'effriter à perf_counter() après environ 100 jours. Ainsi, par exemple, après une année d'activité, le plus court intervalle (supérieur à 0) qu'il peut mesurer sera plus grand qu'au début.
Vous devez importer l'heure, puis utiliser la méthode time.time () pour connaître l'heure actuelle.
import time
start_time=time.time() #taking current time as starting time
#here your code
elapsed_time=time.time()-start_time #again taking current time - starting time
Pour une plus longue période.
import time
start_time = time.time()
...
e = int(time.time() - start_time)
print('{:02d}:{:02d}:{:02d}'.format(e // 3600, (e % 3600 // 60), e % 60))
serait imprimer
00:03:15
si plus de 24 heures
25:33:57
Cela est inspiré par la réponse de Rutger Hofste. Merci Rutger!
La réponse de Vadim Shender est excellente. Vous pouvez également utiliser un décorateur plus simple comme ci-dessous:
import datetime
def calc_timing(original_function):
def new_function(*args,**kwargs):
start = datetime.datetime.now()
x = original_function(*args,**kwargs)
elapsed = datetime.datetime.now()
print("Elapsed Time = {0}".format(elapsed-start))
return x
return new_function()
@calc_timing
def a_func(*variables):
print("do something big!")
Une autre façon pratique de gérer le temps consiste à utiliser la structure with python.
avec la structure appelle automatiquement _ ENTREZ _ et _ EXIT _ méthodes, c’est exactement ce dont nous avons besoin pour chronométrer les choses.
Créons une classe Timer .
from time import time
class Timer():
def __init__(self, message):
self.message = message
def __enter__(self):
self.start = time()
return None # could return anything, to be used like this: with Timer("Message") as value:
def __exit__(self, type, value, traceback):
elapsed_time = (time() - self.start) * 1000
print(self.message.format(elapsed_time))
Ensuite, on peut utiliser la classe Timer comme ceci:
with Timer("Elapsed time to compute some prime numbers: {}ms"):
primes = []
for x in range(2, 500):
if not any(x % p == 0 for p in primes):
primes.append(x)
print("Primes: {}".format(primes))
Le résultat est le suivant:
Primes: [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89 , 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373 , 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499]
Temps écoulé pour calculer certains nombres premiers: 5.01704216003418ms