python - ejemplos - Medición del tiempo transcurrido con el módulo Tiempo.

django

Question

Con el módulo de tiempo en python, ¿es posible medir el tiempo transcurrido? Si es así, ¿cómo hago eso?

Necesito hacer esto para que, si el cursor ha estado en un widget durante un cierto tiempo, ocurre un evento.

Answer 1

Debe importar el tiempo y luego usar el método time.time () para saber la hora actual.

import time
start_time=time.time() #taking current time as starting time
#here your code
elapsed_time=time.time()-start_time #again taking current time - starting time

Answer 2

La respuesta de Vadim Shender es genial. También puedes usar un decorador más simple como el siguiente:

import datetime
def calc_timing(original_function):
def new_function(*args,**kwargs):
start = datetime.datetime.now()
x = original_function(*args,**kwargs)
elapsed = datetime.datetime.now()
print("Elapsed Time = {0}".format(elapsed-start))
return x
return new_function()
@calc_timing
def a_func(*variables):
print("do something big!")

Answer 3

Para la mejor medida del tiempo transcurrido (desde Python 3.3), use time.perf_counter() .

Devuelva el valor (en fracciones de segundos) de un contador de rendimiento, es decir, un reloj con la resolución más alta disponible para medir una duración corta. Incluye el tiempo transcurrido durante la suspensión y se aplica a todo el sistema. El punto de referencia del valor devuelto no está definido, por lo que solo la diferencia entre los resultados de llamadas consecutivas es válida.

Para mediciones en el orden de horas / días, no le importa la resolución de un segundo, así que use docs.python.org/3/library/time.html#time.monotonic lugar.

Devuelve el valor (en fracciones de segundos) de un reloj monotónico, es decir, un reloj que no puede retroceder. El reloj no se ve afectado por las actualizaciones del reloj del sistema. El punto de referencia del valor devuelto no está definido, por lo que solo la diferencia entre los resultados de llamadas consecutivas es válida.

En muchas implementaciones, estas pueden ser la misma cosa.

Antes de 3.3, estás atascado con time.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.

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.

Actualización para Python 3.7

Lo nuevo en Python 3.7 es PEP 564 - Agregar nuevas funciones de tiempo con resolución de nanosegundos.

El uso de estos puede eliminar aún más los errores de redondeo y punto flotante, especialmente si está midiendo periodos muy cortos, o si su aplicación (o la máquina de Windows) es de larga duración.

La resolución comienza a descomponerse en perf_counter() después de unos 100 días. Entonces, por ejemplo, después de un año de actividad, el intervalo más corto (mayor que 0) que puede medir será mayor que cuando comenzó.

Answer 4

Para los usuarios que quieren un mejor formato,

import time
start_time = time.time()
# your script
elapsed_time = time.time() - start_time
time.strftime("%H:%M:%S", time.gmtime(elapsed_time))

se imprimirá, durante 2 segundos:

''00:00:02''

y durante 7 minutos un segundo:

''00:07:01''

tenga en cuenta que la unidad de tiempo mínima con gmtime es segundos. Si necesitas microsegundos considera lo siguiente:

import datetime
start = datetime.datetime.now()
# some code
end = datetime.datetime.now()
elapsed = end - start
print(elapsed)
# or
print(elapsed.seconds,":",elapsed.microseconds)

documentation

Answer 5

Por un período más largo.

import time
start_time = time.time()
...
e = int(time.time() - start_time)
print(''{:02d}:{:02d}:{:02d}''.format(e // 3600, (e % 3600 // 60), e % 60))

imprimiría

00:03:15

si mas de 24 horas

25:33:57

Eso está inspirado en la respuesta de Rutger Hofste. Gracias Rutger!

Answer 6

time.time() hará el trabajo.

import time
start = time.time()
# run your code
end = time.time()
elapsed = end - start

Es posible que desee ver this pregunta, pero no creo que sea necesario.

Answer 7

start_time = time.time()
# your code
elapsed_time = time.time() - start_time

También puede escribir un decorador simple para simplificar la medición del tiempo de ejecución de varias funciones:

import time
from functools import wraps
PROF_DATA = {}
def profile(fn):
@wraps(fn)
def with_profiling(*args, **kwargs):
start_time = time.time()
ret = fn(*args, **kwargs)
elapsed_time = time.time() - start_time
if fn.__name__ not in PROF_DATA:
PROF_DATA[fn.__name__] = [0, []]
PROF_DATA[fn.__name__][0] += 1
PROF_DATA[fn.__name__][1].append(elapsed_time)
return ret
return with_profiling
def print_prof_data():
for fname, data in PROF_DATA.items():
max_time = max(data[1])
avg_time = sum(data[1]) / len(data[1])
print "Function %s called %d times. " % (fname, data[0]),
print ''Execution time max: %.3f, average: %.3f'' % (max_time, avg_time)
def clear_prof_data():
global PROF_DATA
PROF_DATA = {}

Uso:

@profile
def your_function(...):
...

Puede perfilar más de una función simultáneamente. Luego, para imprimir las medidas, simplemente llame a print_prof_data ():