¿Cómo medir el tiempo transcurrido entre líneas de código en Python?

Entonces, en Java, podemos hacer Cómo medir el tiempo que tarda una función en ejecutarse

Pero, ¿cómo se hace en Python? ¿Para medir la hora de inicio y finalización entre líneas de códigos? Algo que hace esto:

import some_time_library

starttime = some_time_library.some_module()
code_tobe_measured() 
endtime = some_time_library.some_module()

time_taken = endtime - starttime

Si desea medir el tiempo de la CPU, puede usarlo time.process_time()para Python 3.3 y superior:

import time
start = time.process_time()
# your code here    
print(time.process_time() - start)

La primera llamada enciende el temporizador y la segunda llamada le dice cuántos segundos han transcurrido.

También hay una función time.clock(), pero está obsoleta desde Python 3.3 y se eliminará en Python 3.8.

Hay mejores herramientas de creación de perfiles como timeity profile, sin embargo, time.process_time () medirá el tiempo de la CPU y esto es lo que está preguntando.

Si desea medir la hora del reloj de pared, utilice time.time().

También puede utilizar la timebiblioteca:

import time

start = time.time()

# your code

# end

print(f'Time: {time.time() - start}')

Con la ayuda de una pequeña clase de conveniencia, puede medir el tiempo empleado en líneas con sangría como esta:

with CodeTimer():
   line_to_measure()
   another_line()
   # etc...

Que mostrará lo siguiente después de que las líneas sangradas terminen de ejecutarse:

Code block took: x.xxx ms

ACTUALIZACIÓN: ahora puede obtener la clase con pip install linetimery luego from linetimer import CodeTimer. Vea este proyecto de GitHub .

El código de la clase anterior:

import timeit

class CodeTimer:
    def __init__(self, name=None):
        self.name = " '"  + name + "'" if name else ''

    def __enter__(self):
        self.start = timeit.default_timer()

    def __exit__(self, exc_type, exc_value, traceback):
        self.took = (timeit.default_timer() - self.start) * 1000.0
        print('Code block' + self.name + ' took: ' + str(self.took) + ' ms')

Luego, podría nombrar los bloques de código que desea medir:

with CodeTimer('loop 1'):
   for i in range(100000):
      pass

with CodeTimer('loop 2'):
   for i in range(100000):
      pass

Code block 'loop 1' took: 4.991 ms
Code block 'loop 2' took: 3.666 ms

Y anidarlos :

with CodeTimer('Outer'):
   for i in range(100000):
      pass

   with CodeTimer('Inner'):
      for i in range(100000):
         pass

   for i in range(100000):
      pass

Code block 'Inner' took: 2.382 ms
Code block 'Outer' took: 10.466 ms

En cuanto a timeit.default_timer(), utiliza el mejor temporizador según el sistema operativo y la versión de Python, consulte esta respuesta .

Siempre prefiero consultar la hora en formato de horas, minutos y segundos (% H:% M:% S):

from datetime import datetime
start = datetime.now()
# your code
end = datetime.now()
time_taken = end - start
print('Time: ',time_taken) 

salida:

Time:  0:00:00.000019

Estaba buscando una forma de generar una hora formateada con un código mínimo, así que aquí está mi solución. Muchas personas usan Pandas de todos modos, por lo que, en algunos casos, esto puede evitar las importaciones de bibliotecas adicionales.

import pandas as pd
start = pd.Timestamp.now()
# code
print(pd.Timestamp.now()-start)

Salida:

0 days 00:05:32.541600

Recomendaría usar esto si la precisión del tiempo no es lo más importante, de lo contrario, use la timebiblioteca:

%timeit pd.Timestamp.now() salidas 3,29 µs ± 214 ns por lazo

%timeit time.time() salidas 154 ns ± 13,3 ns por lazo

Puedes probar esto también:

from time import perf_counter

t0 = perf_counter()

...

t1 = perf_counter()
time_taken = t1 - t0

Poner el código en una función y luego usar un decorador para el tiempo es otra opción. ( Fuente ) La ventaja de este método es que define el temporizador una vez y lo usa con una línea adicional simple para cada función.

Primero, defina timerdecorador:

import functools
import time

def timer(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.perf_counter()
        value = func(*args, **kwargs)
        end_time = time.perf_counter()
        run_time = end_time - start_time
        print("Finished {} in {} secs".format(repr(func.__name__), round(run_time, 3)))
        return value

    return wrapper

Luego, use el decorador mientras define la función:

@timer
def doubled_and_add(num):
    res = sum([i*2 for i in range(num)])
    print("Result : {}".format(res))

Intentemos:

doubled_and_add(100000)
doubled_and_add(1000000)

Salida:

Result : 9999900000
Finished 'doubled_and_add' in 0.0119 secs
Result : 999999000000
Finished 'doubled_and_add' in 0.0897 secs

Nota: no estoy seguro de por qué usar en time.perf_counterlugar de time.time. Los comentarios son bienvenidos.