now - Python''s time.clock() vs. time.time() ¿exactitud?

time.clock python

Question

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

Answer 1

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

Answer 2

A partir de 3.3, time.clock () está en desuso , y se sugiere usar time.process_time() o time.perf_counter() 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, está el módulo de timeit para realizar comparaciones de fragmentos de código.

Answer 3

Como otros han observado, 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 de 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.

Answer 4

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

Answer 5

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

Answer 6

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

Answer 7

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.

Answer 8

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.

Answer 9

Para ampliar los resultados de @ Hill, aquí hay una prueba que usa python 3.4.3 en Xubuntu 16.04 a través del vino:
(timeit.default_timer usará time.clock () porque ve el sistema operativo como ''win32'')

cuando se usa Windows, el reloj () suele ser más preciso, pero este no es el caso del vino ...
Aquí puede ver que time () es más preciso que clock (), que suele ser el caso de Linux y Mac.

Answer 10

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

Answer 11

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

Answer 12

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

En los sistemas * nix, clock () devuelve el tiempo 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 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.

Answer 13

Se prefiere usar time.time ().

Answer 14

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 programador 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 caducó y el caso de prueba se canceló. Tuve que cambiar de time.time() a time.clock() para manejar esto correctamente.

Answer 15

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

Answer 16

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

Answer 17

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.

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