¿Precisión time.clock () vs. time.time () de Python?

¿Qué es mejor usar para cronometrar 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)

vs.

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 los documentos del módulo de tiempo :

time.clock ()

En Unix, devuelve el tiempo actual del procesador como un número de coma flotante expresado en segundos. La precisión, y de hecho la definición misma del significado de "tiempo de procesador", depende de la de la función C del mismo nombre, pero en cualquier caso, esta es la función que se debe usar para comparar algoritmos de Python o temporización.

En Windows, esta función devuelve los segundos del 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 timeit para comparar fragmentos de código.

La respuesta corta es: la mayoría de las veces time.clock()será mejor. Sin embargo, si está cronometrando algo de hardware (por ejemplo, algún algoritmo que puso en la GPU), entonces time.clock()se deshará 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 factores que no puede controlar (cuándo cambiará el proceso, con qué frecuencia, ...), esto es peor con time.time()pero también existe time.clock(), por lo que nunca debe ejecutar una prueba de tiempo solamente, 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 con fines de evaluación comparativa / creación de perfiles, debe echar un vistazo al timeitmódulo .

Una cosa a tener en cuenta: cambiar la hora del sistema afecta time.time()pero no 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 determinada, ese TC se interrumpió para continuar con el siguiente.

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

clock() -> número de coma flotante

Devuelve el tiempo de CPU o en 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 coma flotante

Devuelve el tiempo actual en segundos desde la época. Fracciones de segundo pueden estar presentes si el reloj del sistema las proporciona.

Por time()lo general, 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 el tiempo del sistema (es decir, el tiempo real)

Depende de lo que te importe. Si te refieres a WALL TIME (como en, la hora en el reloj de tu pared), time.clock () NO proporciona precisión porque puede administrar el tiempo de CPU.

time()tiene mejor precisión que clock()en Linux. clock()solo tiene precisión inferior a 10 ms. Mientras que time()da la precisión perfecta. 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.

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

Estas 6 nuevas funciones de resolución en 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 varios nanosegundos como Python int.

Como otros también han notado, use el timeitmódulo para cronometrar funciones y pequeños fragmentos de código.

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 punto en el pasado. En Windows, medirá los segundos del reloj de pared transcurridos desde la primera llamada a la función. En cualquier sistema, time.time () devolverá los segundos transcurridos desde la época.

Si está escribiendo un código que está destinado solo para Windows, cualquiera de los dos funcionará (aunque usará los dos de manera diferente; no es necesario restar para time.clock ()). Si esto se va a ejecutar en un sistema Unix o si desea un código que se garantice que sea portátil, deberá usar time.time ().

Respuesta corta: use time.clock () para cronometrar en Python.

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

time () devuelve los segundos desde la época, en UTC, como un número de coma flotante. No hay garantía de que obtendrá una mejor precisión de 1 segundo (aunque time () devuelve un número de coma 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 de función devolverá un valor inferior.

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

Utilizo este código para comparar 2 métodos. Mi sistema operativo es Windows 8, procesador Core 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 tienen la misma longitud de una fracción.

¿Pero cuál más rápido si subjectes 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 estoy trabajando en un laboratorio suizo pero lo he probado ...

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

Editar: time.clock()es un contador interno, por lo que no se puede usar fuera, tiene limitaciones max 32BIT FLOAT, no se puede continuar contando si no se almacenan los primeros / últimos valores. No se puede fusionar otro contador ...

time.clock()se eliminó en Python 3.8 porque tenía un comportamiento dependiente de la plataforma :

• En Unix , devuelve el tiempo actual del procesador como un número de coma flotante expresado en segundos.

• En Windows , esta función devuelve los segundos del reloj de pared transcurridos desde la primera llamada a esta función, como un número de coma flotante

  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

Entonces, ¿qué función elegir en su lugar?

• Tiempo de procesador : este es el tiempo que este proceso específico pasa ejecutándose activamente en la CPU. La suspensión, la espera de una solicitud web o el tiempo en que solo se ejecutan otros procesos no contribuirán a esto.

  • Utilizar time.process_time()

• Tiempo de reloj de pared : se refiere a cuánto tiempo ha pasado "en un reloj colgado en la pared", es decir, fuera del tiempo real.

  • Utilizar time.perf_counter()

    • time.time() también mide el tiempo del reloj de pared, pero se puede restablecer, por lo que puede retroceder en el tiempo
    • time.monotonic() no se puede restablecer (monótono = solo avanza) pero tiene una precisión menor que time.perf_counter()

Comparación del 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