Time.clock de Python () frente a time.time () ¿exactitud?

¿Cuál es mejor usar para medir el tiempo en Python? time.clock () o time.time ()? ¿Cuál proporciona más precisión?

por ejemplo:

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

contra

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

A partir de 3.3, time.clock () está en desuso , y se sugiere usar time.process_time () o time.perf_counter () en su lugar.

Anteriormente en 2.7, según el módulo de tiempo docs :

hora.clock ()

En Unix, devuelva el tiempo actual del procesador como un número de punto flotante expresado en segundos. La precisión, y de hecho, la definición misma del significado de “tiempo de procesador”, depende de la función C del mismo nombre, pero en cualquier caso, esta es la función que se debe utilizar para la evaluación comparativa de los algoritmos de temporización o de Python.

En Windows, esta función devuelve los segundos de reloj de pared transcurridos desde la primera llamada a esta función, como un número de punto flotante, basado en la función Win32 QueryPerformanceCounter (). La resolución suele ser mejor que un microsegundo.

Además, existe el módulo de timeit para realizar puntos de referencia de fragmentos de código.

La respuesta corta es: la mayor parte del tiempo time.clock() será mejor. Sin embargo, si está sincronizando algún hardware (por ejemplo, algún algoritmo que coloca en la GPU), time.clock() se librará de este tiempo y time.time() es la única solución que queda.

Nota: cualquiera que sea el método utilizado, el tiempo dependerá de los factores que no pueda controlar (cuándo cambiará el proceso, con qué frecuencia, …), esto es peor con time.time() pero existe también con time.clock() , por lo tanto, nunca debe ejecutar solo una prueba de tiempo, pero siempre ejecute una serie de pruebas y observe la media / varianza de los tiempos.

Otros han respondido re: time.time() vs. time.clock() .

Sin embargo, si está cronometrando la ejecución de un bloque de código para fines de evaluación comparativa / creación de perfiles, debe echar un vistazo al módulo timeit .

Una cosa a tener en cuenta: cambiar la hora del sistema afecta a time.time() pero no a time.clock() .

Necesitaba controlar algunas ejecuciones de pruebas automáticas. Si un paso del caso de prueba tomó más de una cantidad de tiempo dada, ese TC fue abortado para continuar con el siguiente.

Pero a veces se necesita un paso para cambiar la hora del sistema (para verificar el módulo del progtwigdor de la aplicación bajo prueba), por lo que después de configurar la hora del sistema unas pocas horas en el futuro, el tiempo de espera de TC expiró y el caso de prueba se canceló. Tuve que cambiar de time.time() a time.clock() para manejar esto correctamente.

clock() -> número de punto flotante

Devuelva el tiempo de CPU o tiempo real desde el inicio del proceso o desde la primera llamada a clock() . Esto tiene tanta precisión como los registros del sistema.

time() -> número de punto flotante

Devuelve la hora actual en segundos desde la Época. Las fracciones de un segundo pueden estar presentes si el reloj del sistema las proporciona.

Generalmente el time() es más preciso, porque los sistemas operativos no almacenan el tiempo de ejecución del proceso con la precisión con la que almacenan la hora del sistema (es decir, la hora real)

Depende de lo que te importa. Si se refiere a TIEMPO DE PARED (como en, la hora del reloj en su pared), time.clock () NO proporciona ninguna precisión porque puede administrar el tiempo de CPU.

Para mi propia practice. time() practice. time() tiene mejor precisión que clock() en Linux. clock() solo tiene una precisión inferior a 10 ms. Mientras que el time() da precisión al prefecto. Mi prueba está en 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 diferencia es muy específica de la plataforma.

clock () es muy diferente en Windows que en Linux, por ejemplo.

Para el tipo de ejemplos que describe, probablemente desee el módulo “timeit” en su lugar.

En Unix time.clock () mide la cantidad de tiempo de CPU que ha utilizado el proceso actual, por lo que no es bueno para medir el tiempo transcurrido desde algún momento en el pasado. En Windows, medirá los segundos de reloj de pared transcurridos desde la primera llamada a la función. En cualquier sistema, time.time () devolverá los segundos pasados ​​desde la época.

Si está escribiendo un código que solo está diseñado para Windows, cualquiera de los dos funcionará (aunque utilizará los dos de manera diferente, no es necesario restar para time.clock ()). Si esto va a ejecutarse en un sistema Unix o si desea un código que se garantiza que sea portátil, querrá usar time.time ().

Respuesta corta: use time.clock () para la sincronización en Python.

En los sistemas * nix, clock () devuelve la hora del procesador como un número de punto flotante, expresado en segundos. En Windows, devuelve los segundos transcurridos desde la primera llamada a esta función, como un número de punto flotante.

time () devuelve los segundos transcurridos desde la época, en UTC, como un número de punto flotante. No hay garantía de que obtendrá una mejor precisión que 1 segundo (aunque el tiempo () devuelva un número de punto flotante). También tenga en cuenta que si el reloj del sistema se ha retrasado entre dos llamadas a esta función, la segunda llamada a la función devolverá un valor más bajo.

A mi entender, time.clock () tiene tanta precisión como su sistema lo permitirá.

Utilizo este código para comparar 2 métodos. Mi sistema operativo es Windows 8, procesador i5, RAM 4GB

 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 

salida:

tiempo () = 0.0993799996376

reloj () = 0.0993572257367

Respuesta correcta: Ambos son la misma longitud de una fracción.

¿Pero que más rápido si el subject es el time ?

Un pequeño caso de prueba :

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

No trabajo en un laboratorio suizo pero lo he probado ..

Basado en esta pregunta: time.clock() es mejor que time.time()

Edición: time.clock() es un contador interno, por lo que no se puede usar en el exterior, tiene limitaciones con un max 32BIT FLOAT , no se puede seguir contando si no se almacenan los valores primero / último. No se puede fusionar otro contador …

Como otros han señalado, time.clock() está en desuso en favor de time.perf_counter() o time.process_time() , pero Python 3.7 introduce el tiempo de resolución en nanosegundos con time.perf_counter_ns() , time.process_time_ns() , y time.time_ns() , junto con otras 3 funciones.

Estas 6 nuevas funciones de resolución de nansegundos se detallan en 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()

Estas funciones son similares a la versión sin el sufijo _ns, pero devuelven una cantidad de nanosegundos como un int de Python.

Como otros también han señalado, use el módulo timeit para timeit funciones y pequeños fragmentos de código.

Comparando el resultado de la prueba entre Ubuntu Linux y Windows 7.

En Ubuntu

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

En Windows 7

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

Usar el time.time () es el preferido.