Medición del tiempo transcurrido con el módulo Tiempo

8 minutos de lectura

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 tiempo determinado, ocurra un evento.

  • NB que cualquier respuesta usando time.time() Es incorrecto. El ejemplo más simple es si la hora del sistema cambia durante el período de medición.

    – perro naranja

    4 de diciembre de 2017 a las 16:46

  • Para su pregunta original sobre la activación de un evento si un cursor permanece durante un cierto tiempo en un widget, docs.python.org/3/library/threading.html proporciona todo lo que necesita, creo. El subprocesamiento múltiple y una variable de condición con tiempo de espera podrían ser una de las soluciones. Sus circunstancias, sin embargo, actualmente no están claras para responder.

    – Torá

    18 de marzo de 2018 a las 18:04


  • No hay ninguna razón por la que alguien deba usar time.time() para medir el tiempo transcurrido en Python moderno (afectado por cambios manuales, deriva, segundos intercalares, etc.). Esta respuesta a continuación debe ser más alta, considerando que esta pregunta ahora es el resultado principal en Google para medir el tiempo transcurrido.

    – NPras

    7 de noviembre de 2018 a las 0:42


  • También puede medir el tiempo con el generador de perfiles cProfile: docs.python.org/3/library/profile.html#module-cProfile stackoverflow.com/questions/582336/…

    – Antón Tarasenko

    19 de diciembre de 2018 a las 12:54

  • @NPras olvida “python moderno”. Siempre fue incorrecto usar time.time().

    – perro naranja

    18 mayo 2020 a las 21:20

avatar de usuario
Vadim Shender

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

  • También puedes echar un vistazo a ganchos de perfil pip install profilehooksy es página de inicio aquí

    – pijama

    5 de enero de 2013 a las 5:08

  • Tenga en cuenta que desde Python 3.3, probablemente debería usar time.monotonic() en lugar time.time() al medir tiempos de espera o duraciones. docs.python.org/3/library/time.html#time.monotonic

    – Debilski

    18 mayo 2015 a las 21:53

  • Vale la pena agregar/observar aquí que la unidad de medida del tiempo transcurrido será segundos.

    –Eric Kramer

    16 de enero de 2016 a las 3:59

  • @EricKramer gracias! una gran molestia mía, explicar las medidas sin definir la unidad de medida. Y como un tipo de .NET sumergiendo los dedos de los pies en Python por primera vez, automáticamente pensé “milisegundos”.

    – Adam Plocher

    30 de noviembre de 2016 a las 1:01

  • No funciona si (por ejemplo) se cambia el reloj del sistema y es posible que no tenga una resolución de subsegundos. Respuesta correcta: stackoverflow.com/a/47637891/476716

    – perro naranja

    4 de diciembre de 2017 a las 16:44

avatar de usuario
lali

time.time() hará el trabajo.

import time

start = time.time()
# run your code
end = time.time()

elapsed = end - start

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

  • si, el tiempo es en segundos

    –Eric Kramer

    16 de enero de 2016 a las 3:58

  • Debe cambiar start a start_time.

    -Zoran Pandovski

    30 de enero de 2020 a las 14:24

  • time.time() es una mala idea porque el reloj del sistema se puede reiniciar, lo que te hará retroceder en el tiempo. time.monotonic() se encarga de esto (monotónico = solo avanza). time.perf_counter() también es monótono pero tiene una precisión aún mayor, por lo que se recomienda para la hora del reloj de pared.

    – xjcl

    31 de mayo de 2020 a las 11:19

avatar de usuario
rutger hofste

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

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 necesita microsegundos considere 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) 

strftime documentación

  • Gracias por tu respuesta, que me inspira. voy a usar e = time.time() - start_time ; print("%02d:%02d:%02d" % (e // 3600, (e % 3600 // 60), (e % 60 // 1))) eso produce casi lo mismo además de cubrir la situación que transcurre más de 24 horas.

    – Torá

    18 de marzo de 2018 a las 17:06

  • @Tora, es posible que desee consultar “{}”.format() en lugar de %02d para futuros problemas de compatibilidad.

    –Rutger Hofste

    19 de marzo de 2018 a las 9:26

  • ¡gracias! Ahora me estoy acostumbrando a la nueva. ‘{:02d}:{:02d}:{:02d}’.formato(e // 3600, (e % 3600 // 60), e % 60)

    – Torá

    15 de abril de 2018 a las 18:38

  • puedes usar time.monotonic() como en las otras respuestas?

    – endolito

    5 sep 2019 a las 20:19

  • elapsed.seconds será incorrecta si la duración es superior a un día. Usted quiere elapsed.total_seconds() ser resistente

    – Ash Berlín-Taylor

    3 de junio de 2020 a las 14:36

avatar de usuario
naranjaperro

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

Devuelve el valor (en fracciones de segundo) 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 el sueño y es para todo el sistema. El punto de referencia del valor devuelto no está definido, por lo que solo es válida la diferencia entre los resultados de llamadas consecutivas.

Para mediciones en el orden de horas/días, no le importa la resolución de subsegundos, así que use time.monotonic() en cambio.

Devuelve el valor (en fracciones de segundo) de un reloj monótono, 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 es válida la diferencia entre los resultados de llamadas consecutivas.

En muchas implementaciones, en realidad pueden ser lo mismo.

Antes de 3.3, estás atascado con time.clock().

En Unix, devuelve 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 coma flotante, según la función de Win32 QueryPerformanceCounter(). La resolución suele ser mejor que un microsegundo.


Actualización para Python 3.7

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 períodos muy cortos o si su aplicación (o máquina con Windows) tiene una ejecución prolongada.

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


Actualización para Python 3.8

time.clock ahora se ha ido

avatar de usuario
Torá

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!

avatar de usuario
xjcl

En la programación hay 2 formas principales de medir el tiempocon diferentes resultados:

>>> print(time.process_time()); time.sleep(10); print(time.process_time())
0.11751394000000001
0.11764988400000001  # took  0 seconds and a bit
>>> print(time.perf_counter()); time.sleep(10); print(time.perf_counter())
3972.465770326
3982.468109075       # took 10 seconds and a bit
  • Tiempo del 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.

    • Usar time.process_time()
  • Hora del reloj de pared: Esto se refiere a cuánto tiempo ha pasado “en un reloj colgado en la pared”, es decir, fuera del tiempo real.

    • Usar time.perf_counter()

      • time.time() también mide el tiempo del reloj de pared, pero se puede reiniciar, por lo que podría retroceder en el tiempo
      • time.monotonic() no se puede restablecer (monotónico = solo avanza) pero tiene menor precisión que time.perf_counter()

Debe importar la hora y luego usar el método time.time() para conocer 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 

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad