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

428

¿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)
Corey Goldberg
fuente
32
Tenga en cuenta que a partir de Python 3.3, el uso de time.clock()está en desuso y se recomienda su uso perf_counter()o en su process_time()lugar.
Cody Piersall
Vea este comentario sobre cómo se suman todos los núcleos utilizados por un proceso time.clocky time.process_time, pero no los procesos secundarios. También vea esta discusión sobre la precisión (por supuesto, varía según el sistema).
máximo

Respuestas:

161

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.

Jason Navarrete
fuente
44
"Esta es la función que se debe usar para evaluar los algoritmos de sincronización o Python". <br> Los documentos de Python no parecen ser precisos según las respuestas que se dan aquí. time.clock () no siempre es lo que desea para la evaluación comparativa. especialmente con la existencia del módulo timeit
Corey Goldberg
1
@ Corey Goldberg: entonces, ¿envió un error de documentación ? (Significaban "use clock () en lugar de time () : pero sí es descuidado)
smci
3
Como se puede leer aquí , parece que el comportamiento time.clock()dependía de la plataforma, y time.process_time()no lo es. Esta es la razón por la cual time.clock()fue desaprobado.
Jim Aho
46

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.

PierreBdR
fuente
también cuando solicite recursos de red de forma asíncrona (el proceso se bloqueará para esperar), se eliminará el tiempo de red.
dasons
25

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 .

dF.
fuente
16
+1: timeit.default_timerse asigna time.time()o time.clock()depende del sistema operativo. En Python 3.3+ default_timerestá time.perf_counter()en todas las plataformas.
jfs
19

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.

Seba
fuente
1
Yo estaba buscando esto. Gracias :) Me ayudará incluso si un usuario cambia su hora del sistema operativo.
Aashiq Hussain
¿Cómo puedo comparar esta hora y la almacenada por el usuario en formato de hora: minuto?
Aashiq Hussain
19

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)

Vinko Vrsalovic
fuente
17

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.

usuario15910
fuente
1
exactamente, acabo de usar time.clock()en un servidor Linux y los números que obtuve definitivamente no fueron segundos
Roman Plášil
15

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
bestwolf1983
fuente
así que supongo tiempo () en vino ??
Tcll
6

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.

Justin Sheehy
fuente
3
¿podría expandirse, de qué manera clockes "very different"?
n611x007
5

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.

Chris_Rands
fuente
3

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


fuente
2

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.

Babak
fuente
2

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

Jake
fuente
2

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

Nurul Akter Towhid
fuente
1

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

dsgdfg
fuente
0

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()
xjcl
fuente
-1

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
colina
fuente
por favor lea las otras respuestas para entender la diferencia en windows vs.unix / linux.
Corey Goldberg