Precisione di time.clock () vs. time.time () di Python?

Quale è meglio usare per il timing in Python? time.clock () o time.time ()? Quale fornisce una maggiore precisione?

per esempio:

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

vs.

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

A partire da 3.3, time.clock () è obsoleto ed è consigliabile utilizzare invece time.process_time () o time.perf_counter () .

Precedentemente in 2.7, secondo i documenti del modulo temporale :

time.clock ()

Su Unix, restituisce il tempo corrente del processore come un numero in virgola mobile espresso in secondi. La precisione, e in effetti la definizione stessa del significato di "tempo del processore", dipende da quella della funzione C con lo stesso nome, ma in ogni caso, questa è la funzione da utilizzare per il benchmarking di Python o algoritmi di temporizzazione.

Su Windows, questa funzione restituisce i secondi dell'orologio da parete trascorsi dalla prima chiamata a questa funzione, come numero in virgola mobile, in base alla funzione Win32 QueryPerformanceCounter (). La risoluzione è in genere migliore di un microsecondo.

Inoltre, esiste il modulo timeit per l'analisi comparativa degli snippet di codice.

La risposta breve è: la maggior parte delle volte time.clock()sarà migliore. Tuttavia, se stai programmando un po 'di hardware (ad esempio un algoritmo che hai inserito nella GPU), allora time.clock()ti libererai di questo tempo ed time.time()è l'unica soluzione rimasta.

Nota: qualunque sia il metodo utilizzato, i tempi dipenderanno da fattori che non puoi controllare (quando cambierà il processo, con quale frequenza, ...), questo è peggio time.time()ma esiste anche con time.clock(), quindi non dovresti mai eseguire un solo test di temporizzazione, ma esegui sempre una serie di test e osserva media / varianza dei tempi.

Altri hanno risposto Re: time.time()contro time.clock().

Tuttavia, se stai programmando l'esecuzione di un blocco di codice per scopi di benchmarking / profiling, dovresti dare un'occhiata al timeitmodulo .

Una cosa da tenere a mente: la modifica dell'ora di sistema influisce time.time()ma non time.clock().

Avevo bisogno di controllare alcune esecuzioni di test automatici. Se un passaggio del caso di test ha richiesto più di un determinato periodo di tempo, quel TC è stato interrotto per proseguire con il successivo.

Ma a volte è necessario un passaggio per modificare il tempo di sistema (per controllare il modulo di pianificazione dell'applicazione in prova), quindi dopo aver impostato l'ora di sistema alcune ore in futuro, il timeout del TC è scaduto e il test case è stato interrotto. Ho dovuto passare da time.time()a time.clock()per gestirlo correttamente.

clock() -> numero in virgola mobile

Restituisce il tempo della CPU o il tempo reale dall'inizio del processo o dalla prima chiamata a clock(). Ciò ha la stessa precisione dei record di sistema.

time() -> numero in virgola mobile

Restituisce l'ora corrente in secondi dall'epoca. Frazioni di secondo possono essere presenti se l'orologio di sistema le fornisce.

Di solito time()è più preciso, perché i sistemi operativi non memorizzano il tempo di esecuzione del processo con la precisione che memorizzano il tempo di sistema (cioè il tempo effettivo)

Dipende da ciò che ti interessa. Se intendi WALL TIME (come in, l'ora dell'orologio sul tuo muro), time.clock () NON fornisce alcuna precisione perché può gestire il tempo della CPU.

time()ha una precisione migliore rispetto clock()a Linux. clock()ha solo una precisione inferiore a 10 ms. Mentre time()dà la massima precisione. Il mio test è su 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 differenza è molto specifica per la piattaforma.

clock () è molto diverso su Windows che su Linux, per esempio.

Per il tipo di esempi che descrivi, probabilmente vorrai invece il modulo "timeit".

Come altri hanno notato time.clock()è deprecato in favore di time.perf_counter()o time.process_time(), ma i tempi risoluzione Python 3.7 introduce nanosecondo con time.perf_counter_ns(), time.process_time_ns()e time.time_ns(), insieme ad altri 3 funzioni.

Queste 6 nuove funzioni di risoluzione al secondo sono dettagliate in 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()

Queste funzioni sono simili alla versione senza il suffisso _ns, ma restituiscono un numero di nanosecondi come int Python.

Come altri hanno anche notato, utilizzare il timeitmodulo per cronometrare funzioni e piccoli frammenti di codice.

Su Unix time.clock () misura la quantità di tempo della CPU utilizzata dal processo corrente, quindi non è utile per misurare il tempo trascorso da un certo punto in passato. Su Windows misurerà i secondi dell'orologio da parete trascorsi dalla prima chiamata alla funzione. In entrambi i sistemi time.time () restituirà i secondi trascorsi dall'epoca.

Se stai scrivendo un codice che è destinato solo a Windows, entrambi funzioneranno (anche se utilizzerai i due in modo diverso - non è necessaria alcuna sottrazione per time.clock ()). Se questo verrà eseguito su un sistema Unix o desideri che il codice sia garantito come portatile, ti consigliamo di utilizzare time.time ().

Risposta breve: utilizzare time.clock () per il timing in Python.

Sui sistemi * nix, clock () restituisce il tempo del processore come un numero in virgola mobile, espresso in secondi. Su Windows, restituisce i secondi trascorsi dalla prima chiamata a questa funzione, come numero in virgola mobile.

time () restituisce i secondi dall'epoca, in UTC, come un numero in virgola mobile. Non vi è alcuna garanzia che otterrete una migliore precisione di 1 secondo (anche se time () restituisce un numero in virgola mobile). Si noti inoltre che se l'orologio di sistema è stato ripristinato tra due chiamate a questa funzione, la seconda chiamata restituirà un valore inferiore.

Per quanto ne so, time.clock () ha la stessa precisione che il tuo sistema lo permetterà.

Uso questo codice per confrontare 2 metodi. Il mio sistema operativo è Windows 8, processore i5 core, RAM da 4 GB

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

produzione:

time () = 0,0993799996376

clock () = 0,0993572257367

Risposta giusta: hanno entrambi la stessa lunghezza di una frazione.

Ma quale più veloce se lo subjectè time?

Un piccolo test case :

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)))

Non lavoro in un laboratorio svizzero ma ho testato ..

Sulla base di questa domanda: time.clock()è meglio ditime.time()

Modifica: time.clock()è un contatore interno, quindi non può essere utilizzato all'esterno, ha limitazioni max 32BIT FLOAT, non può continuare il conteggio se non memorizza il primo / ultimo valore. Impossibile unire un altro contatore ...

time.clock()è stato rimosso in Python 3.8 perché aveva un comportamento dipendente dalla piattaforma :

• Su Unix , restituisce il tempo corrente del processore come un numero in virgola mobile espresso in secondi.

• Su Windows , questa funzione restituisce i secondi dell'orologio da parete trascorsi dalla prima chiamata a questa funzione, come numero in virgola mobile

  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

Quindi quale funzione scegliere invece?

• Tempo del processore : indica quanto tempo questo processo specifico impiega attivamente per essere eseguito sulla CPU. La sospensione, l'attesa di una richiesta Web o il momento in cui vengono eseguiti solo altri processi non contribuiranno a questo.

  • Uso time.process_time()

• Orologio da parete : si riferisce a quanto tempo è trascorso "su un orologio appeso al muro", cioè al di fuori del tempo reale.

  • Uso time.perf_counter()

    • time.time() misura anche l'ora dell'orologio da parete ma può essere ripristinata, in modo da poter tornare indietro nel tempo
    • time.monotonic() non può essere ripristinato (monotonico = va solo avanti) ma ha una precisione inferiore a time.perf_counter()

Confronto del risultato del test tra Ubuntu Linux e Windows 7.

Su Ubuntu

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

Su Windows 7

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