it-swarm.it

L'accuratezza time.time () di Python rispetto a time.time ()?

Quale è meglio usare per i tempi in Python? time.clock () o time.time ()? Quale fornisce più precisione?

per esempio:

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

vs.

start = time.time()
... do something
elapsed = (time.time() - start)
410
Corey Goldberg

A partire da 3.3, time.clock () è deprecato , e si consiglia di usare time.process_time () o time.perf_counter () invece.

Precedentemente in 2.7, in base al modulo del tempo doc:

time.clock ()

Su Unix, restituisci 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 Algoritmi di Python o temporizzazione.

Su Windows, questa funzione restituisce secondi di orologio a muro trascorsi dalla prima chiamata a questa funzione, come un numero in virgola mobile, basato sulla funzione Win32 QueryPerformanceCounter (). La risoluzione è in genere migliore di un microsecondo.

Inoltre, c'è il timeit modulo per il benchmarking di snippet di codice.

147
Jason Navarrete

La risposta breve è: la maggior parte delle volte time.clock() sarà migliore. Tuttavia, se stai calcolando un po 'di hardware (per esempio alcuni algoritmi che inserisci nella GPU), allora time.clock() si sbarazzerà di questa volta e 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 con time.time() ma esiste anche con time.clock(), quindi non dovresti mai eseguire un test di temporizzazione solo, ma esegui sempre una serie di test e guarda la media/varianza dei tempi.

45
PierreBdR

Altri hanno risposto a: time.time() vs. time.clock().

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

25
dF.

Una cosa da tenere a mente: la modifica del tempo di sistema influisce su time.time() ma non su time.clock().

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

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

19
Seba

clock() -> numero a virgola mobile

Restituisce il tempo della CPU o in tempo reale dall'inizio del processo o dalla prima chiamata a clock(). Questo ha la precisione con cui il sistema registra.

time() -> numero a virgola mobile

Restituisce l'ora corrente in secondi da Epoch. Possono essere presenti frazioni di secondo se l'orologio di sistema le fornisce.

Solitamente time() è più preciso, poiché i sistemi operativi non memorizzano il tempo di esecuzione del processo con la precisione con cui memorizzano l'ora del sistema (cioè l'ora effettiva)

18
Vinko Vrsalovic

Dipende da cosa ti interessa. Se intendi WALL TIME (come in, l'ora sull'orologio sulla tua parete), time.clock () non fornisce accuratezza perché potrebbe gestire il tempo della CPU.

17
user15910

Per il mio practice. time() ha una precisione migliore di clock() su Linux. clock() ha solo una precisione inferiore a 10 ms. Mentre time() fornisce la precisione del prefetto. 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
13
bestwolf1983

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 preferisci il modulo "timeit".

6
Justin Sheehy

Su Unix time.clock () misura la quantità di tempo della CPU che è stata utilizzata dal processo corrente, quindi non è utile per misurare il tempo trascorso da qualche punto nel passato. Su Windows misurerà i secondi di orologio a muro trascorsi dalla prima chiamata alla funzione. Su entrambi i sistemi time.time () restituirà i secondi trascorsi dall'Epoca.

Se stai scrivendo un codice che è pensato solo per Windows, funzionerà (anche se userai i due in modo diverso - non è necessaria alcuna sottrazione per time.clock ()). Se questo verrà eseguito su un sistema Unix o se si desidera che il codice sia portatile, si vorrà utilizzare time.time ().

3
auspace

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

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

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

2
Babak

Uso questo codice per confrontare 2 metodi. Il mio sistema operativo è Windows 8, processore core i5, RAM 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

orologio () = 0.0993572257367

2

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

Queste 6 nuove funzioni di risoluzione nansecond 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 di Python.

Come altri hanno anche notato, usa il timeit module per le funzioni temporali e i frammenti di codice piccoli.

2
Chris_Rands

Per quanto ne so, time.clock () ha la precisione che il tuo sistema gli consente.

2
Jake

Risposta corretta: Sono entrambi della stessa lunghezza di una frazione.

Ma quale più veloce se 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 nei laboratori svizzeri ma ho provato ..

Basato su questa domanda: time.clock() è meglio di time.time()

Modifica: time.clock() è un contatore interno quindi non può utilizzare all'esterno, ha limitazioni max 32BIT FLOAT, non può continuare il conteggio se non memorizza i primi/ultimi valori. Impossibile unire un altro contatore ...

1
dsgdfg