Mesure du temps écoulé avec le module Time

Question

Avec le module Time de python, est-il possible de mesurer le temps écoulé ? Si oui, comment puis-je le faire ?

Je dois faire en sorte que si le curseur est resté dans un widget pendant une certaine durée, un événement se produise.

Answer 1

start_time = time.time()
# your code
elapsed_time = time.time() - start_time

Vous pouvez également écrire un décorateur simple 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.__name__ 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 = {}

Utilisation :

@profile
def your_function(...):
    ...

Vous pouvez profiler plus d'une fonction simultanément. Ensuite, pour imprimer les mesures, il suffit d'appeler la fonction print_prof_data() :

Answer 2

time.time() fera l'affaire.

import time

start = time.time()
# run your code
end = time.time()

elapsed = end - start

Vous pouvez consulter ce question, mais je ne pense pas que ce sera nécessaire.

Answer 3

Pour les utilisateurs qui souhaitent un meilleur formatage,

import time
start_time = time.time()
# your script
elapsed_time = time.time() - start_time
time.strftime("%H:%M:%S", time.gmtime(elapsed_time))

s'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 la seconde. Si vous avez besoin de microsecondes, considérez ce qui suit :

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

Answer 4

Pour la meilleure mesure du temps écoulé (depuis Python 3.3), utilisez time.perf_counter() .

Renvoie la valeur (en secondes fractionnées) d'un compteur de performance, c'est-à-dire une horloge avec la plus haute résolution disponible pour mesurer une courte durée. Elle inclut le temps écoulé pendant le sommeil et s'applique à l'ensemble du système. Le point de référence de la valeur retournée est indéfini, de sorte que seule la différence entre les résultats d'appels consécutifs est valable.

Pour des mesures de l'ordre de l'heure ou du jour, vous ne vous souciez pas de la résolution à la seconde près. time.monotonic() à la place.

Renvoie la valeur (en secondes fractionnaires) d'une horloge monotonique, 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 du système. Le point de référence de la valeur retournée est indéfini, de sorte que seule la différence entre les résultats d'appels consécutifs est valable.

Dans de nombreuses implémentations, il s'agit en fait de la même chose.

Avant la version 3.3, vous devez vous contenter de time.clock() .

Sous Unix, renvoie le temps actuel du processeur sous la forme d'un 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 les secondes d'horloge murale écoulées depuis le premier appel à cette fonction, sous la forme d'un 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é de Python 3.7 est PEP 564 -- Ajout de nouvelles fonctions temporelles avec une résolution de l'ordre de la nanoseconde.

Leur utilisation permet d'éliminer davantage les erreurs d'arrondi et de virgule flottante, en particulier si vous mesurez des périodes très courtes, ou si votre application (ou votre machine Windows) fonctionne depuis longtemps.

La résolution commence à tomber en panne le perf_counter() après environ 100 jours. Ainsi, par exemple, après un an de fonctionnement, l'intervalle le plus court (supérieur à 0) qu'il peut mesurer sera plus grand qu'au début.

---

Mise à jour pour Python 3.8

time.clock a maintenant disparu.

Answer 5

Pour une période plus longue.

import time
start_time = time.time()
...
e = int(time.time() - start_time)
print('{:02d}:{:02d}:{:02d}'.format(e // 3600, (e % 3600 // 60), e % 60))

imprimerait

00:03:15

si plus de 24 heures

25:33:57

Cela s'inspire de la réponse de Rutger Hofste. Merci Rutger !