Précision time.clock () vs time.time () de Python?

Quel est le meilleur à utiliser pour le chronométrage en Python? time.clock () ou time.time ()? Lequel offre plus de précision?

par exemple:

start = time.clock()
... do something
elapsed = (time.clock() - start)

contre.

start = time.time()
... do something
elapsed = (time.time() - start)

Depuis 3.3, time.clock () est obsolète , et il est suggéré d'utiliser à la place time.process_time () ou time.perf_counter () .

Auparavant en 2.7, selon les documents du module de temps :

time.clock ()

Sous Unix, renvoyez le temps processeur actuel 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 du «temps processeur», dépend de celle de la fonction C du même nom, mais en tout cas, c'est la fonction à utiliser pour comparer Python ou les algorithmes de synchronisation.

Sous Windows, cette fonction renvoie les secondes de l'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.

De plus, il existe le module timeit pour comparer les extraits de code.

La réponse courte est: la plupart du temps, ce time.clock()sera mieux. Cependant, si vous chronométrez du matériel (par exemple un algorithme que vous mettez dans le GPU), alors time.clock()vous vous débarrasserez de ce temps et time.time()c'est la seule solution qui reste.

Remarque: quelle que soit la méthode utilisée, le timing dépendra de facteurs que vous ne pouvez pas contrôler (quand le processus changera-t-il, à quelle fréquence, ...), c'est pire avec time.time()mais existe aussi avec time.clock(), donc vous ne devriez jamais exécuter un seul test de timing, mais toujours exécuter une série de tests et regarder la moyenne / variance des temps.

D' autres ont répondu Re: time.time()vs time.clock().

Cependant, si vous chronométrez l'exécution d'un bloc de code à des fins d'analyse comparative / de profilage, vous devriez jeter un œil au timeitmodule .

Une chose à garder à l'esprit: la modification de l'heure du système affecte time.time()mais pas time.clock().

J'avais besoin de contrôler certaines exécutions de tests automatiques. Si une étape du scénario de test prenait plus d'un certain temps, ce TC était interrompu pour passer à la suivante.

Mais parfois, une étape était nécessaire pour modifier l'heure système (pour vérifier le module de planification de l'application en cours de test), donc après avoir réglé l'heure système quelques heures à l'avenir, le délai d'expiration TC a expiré et le scénario de test a été abandonné. J'ai dû passer de time.time()à time.clock()pour gérer cela correctement.

clock() -> nombre à virgule flottante

Renvoie le temps CPU ou temps réel depuis le début du processus ou depuis le premier appel à clock(). Cela a autant de précision que les enregistrements du système.

time() -> nombre à virgule flottante

Renvoie l'heure actuelle en secondes depuis l'époque. Des fractions de seconde peuvent être présentes si l'horloge système les fournit.

time()Est généralement plus précis, car les systèmes d'exploitation ne stockent pas le temps d'exécution du processus avec la précision qu'ils stockent l'heure du système (c'est-à-dire l'heure réelle)

Cela dépend de ce qui vous intéresse. Si vous voulez dire WALL TIME (comme dans, l'heure sur l'horloge de votre mur), time.clock () ne fournit AUCUNE précision car il peut gérer le temps CPU.

time()a une meilleure précision que clock()sur Linux. clock()n'a qu'une précision inférieure à 10 ms. Alors time()donne la précision du préfet. Mon test est sur CentOS 6.4 ， python 2.6

using time():

1 requests, response time: 14.1749382019 ms
2 requests, response time: 8.01301002502 ms
3 requests, response time: 8.01491737366 ms
4 requests, response time: 8.41021537781 ms
5 requests, response time: 8.38804244995 ms

using clock():

1 requests, response time: 10.0 ms
2 requests, response time: 0.0 ms 
3 requests, response time: 0.0 ms
4 requests, response time: 10.0 ms
5 requests, response time: 0.0 ms 
6 requests, response time: 0.0 ms
7 requests, response time: 0.0 ms 
8 requests, response time: 0.0 ms

La différence est très spécifique à la plate-forme.

horloge () est très différente sur Windows que sur Linux, par exemple.

Pour le genre d'exemples que vous décrivez, vous préférez probablement le module "timeit" à la place.

Comme d' autres l' ont noté time.clock()est dépréciée en faveur time.perf_counter()ou time.process_time(), mais Python 3.7 introduit le calendrier de résolution nanoseconde avec time.perf_counter_ns(), time.process_time_ns()et time.time_ns(), ainsi que 3 autres fonctions.

Ces 6 nouvelles fonctions de résolution en nansecondes sont détaillées dans le PEP 564 :

time.clock_gettime_ns(clock_id)

time.clock_settime_ns(clock_id, time:int)

time.monotonic_ns()

time.perf_counter_ns()

time.process_time_ns()

time.time_ns()

Ces fonctions sont similaires à la version sans le suffixe _ns, mais renvoient un certain nombre de nanosecondes sous la forme d'un int Python.

Comme d'autres l'ont également noté, utilisez le timeitmodule pour chronométrer les fonctions et les petits extraits de code.

Sous Unix time.clock () mesure la quantité de temps CPU qui a été utilisée par le processus actuel, donc ce n'est pas bon pour mesurer le temps écoulé à un moment donné dans le passé. Sous Windows, il mesurera les secondes de l'horloge murale écoulées depuis le premier appel à la fonction. Sur l'un ou l'autre système, time.time () renverra les secondes écoulées depuis l'époque.

Si vous écrivez du code destiné uniquement à Windows, l'un ou l'autre fonctionnera (bien que vous utiliserez les deux différemment - aucune soustraction n'est nécessaire pour time.clock ()). Si cela va s'exécuter sur un système Unix ou si vous voulez que le code soit garanti portable, vous voudrez utiliser time.time ().

Réponse courte: utilisez time.clock () pour le chronométrage en Python.

Sur les systèmes * nix, clock () renvoie le temps processeur sous la forme d'un nombre à virgule flottante, exprimé en secondes. Sous Windows, il renvoie les secondes écoulées depuis le premier appel à cette fonction, sous forme de nombre à virgule flottante.

time () renvoie les secondes depuis l'époque, en UTC, sous forme de nombre à virgule flottante. Il n'y a aucune garantie que vous obtiendrez une meilleure précision que 1 seconde (même si time () renvoie un nombre à virgule flottante). Notez également que si l'horloge système a été réglée entre deux appels à cette fonction, le deuxième appel de fonction renverra une valeur inférieure.

Au meilleur de ma compréhension, time.clock () a autant de précision que votre système le permet.

J'utilise ce code pour comparer 2 méthodes. Mon système d'exploitation est Windows 8, processeur core i5, RAM 4 Go

import time

def t_time():
    start=time.time()
    time.sleep(0.1)
    return (time.time()-start)


def t_clock():
    start=time.clock()
    time.sleep(0.1)
    return (time.clock()-start)




counter_time=0
counter_clock=0

for i in range(1,100):
    counter_time += t_time()

    for i in range(1,100):
        counter_clock += t_clock()

print "time() =",counter_time/100
print "clock() =",counter_clock/100

production:

temps () = 0,0993799996376

horloge () = 0,0993572257367

Bonne réponse: ils ont tous deux la même longueur d'une fraction.

Mais qui plus vite si subjectest time?

Un petit cas de test :

import timeit
import time

clock_list = []
time_list = []

test1 = """
def test(v=time.clock()):
    s = time.clock() - v
"""

test2 = """
def test(v=time.time()):
    s = time.time() - v
"""
def test_it(Range) :
    for i in range(Range) :
        clk = timeit.timeit(test1, number=10000)
        clock_list.append(clk)
        tml = timeit.timeit(test2, number=10000)
        time_list.append(tml)

test_it(100)

print "Clock Min: %f Max: %f Average: %f" %(min(clock_list), max(clock_list), sum(clock_list)/float(len(clock_list)))
print "Time  Min: %f Max: %f Average: %f" %(min(time_list), max(time_list), sum(time_list)/float(len(time_list)))

Je ne travaille pas dans un laboratoire suisse mais j'ai testé ..

Sur la base de cette question: time.clock()est mieux quetime.time()

Modifier: time.clock()est un compteur interne donc ne peut pas être utilisé à l'extérieur, a des limitations max 32BIT FLOAT, ne peut pas continuer à compter s'il ne stocke pas les premières / dernières valeurs. Impossible de fusionner un autre compteur ...

time.clock()a été supprimé dans Python 3.8 car il avait un comportement dépendant de la plateforme :

• Sous Unix , renvoyez le temps processeur actuel sous la forme d'un nombre à virgule flottante exprimé en secondes.

• Sous Windows , cette fonction renvoie les secondes de l'horloge murale écoulées depuis le premier appel à cette fonction, sous forme de nombre à virgule flottante

  print(time.clock()); time.sleep(10); print(time.clock())
  # Linux  :  0.0382  0.0384   # see Processor Time
  # Windows: 26.1224 36.1566   # see Wall-Clock Time

Alors, quelle fonction choisir à la place?

• Temps processeur : c'est la durée pendant laquelle ce processus spécifique passe activement à s'exécuter sur le CPU. La mise en veille, l'attente d'une demande Web ou le moment où seuls d'autres processus sont exécutés n'y contribueront pas.

  • Utilisation time.process_time()

• Horloge murale : il s'agit du temps qui s'est écoulé "sur une horloge suspendue au mur", c'est-à-dire en dehors du temps réel.

  • Utilisation time.perf_counter()

    • time.time() mesure également l'heure de l'horloge murale mais peut être réinitialisée, vous pouvez donc remonter dans le temps
    • time.monotonic() ne peut pas être réinitialisé (monotone = ne fait que progresser) mais a une précision inférieure à time.perf_counter()

Comparaison du résultat du test entre Ubuntu Linux et Windows 7.

Sur Ubuntu

>>> start = time.time(); time.sleep(0.5); (time.time() - start)
0.5005500316619873

Sous Windows 7

>>> start = time.time(); time.sleep(0.5); (time.time() - start)
0.5