Cómo calcular el intervalo de tiempo entre dos cadenas de tiempo

Tengo dos veces, una hora de inicio y otra de parada, en el formato de 10:33:26 (HH: MM: SS). Necesito la diferencia entre los dos tiempos. He estado buscando en la documentación de Python y buscando en línea, y me imagino que tendría algo que ver con los módulos de fecha y hora. No puedo hacer que funcione correctamente y sigo encontrando solo cómo hacer esto cuando se trata de una fecha.

En última instancia, necesito calcular los promedios de varias duraciones de tiempo. Tengo las diferencias horarias para trabajar y las estoy almacenando en una lista. Ahora necesito calcular el promedio. Estoy usando expresiones regulares para analizar los tiempos originales y luego hacer las diferencias.

Para el promedio, ¿debo convertir a segundos y luego promediar?

Sí, definitivamente la datetime la datetime es lo que necesitas aquí. Específicamente, la función strptime , que analiza una cadena en un objeto de tiempo.

 from datetime import datetime s1 = '10:33:26' s2 = '11:15:49' # for example FMT = '%H:%M:%S' tdelta = datetime.strptime(s2, FMT) - datetime.strptime(s1, FMT) 

Eso te da un objeto timedelta que contiene la diferencia entre las dos veces. Puede hacer lo que quiera con eso, por ejemplo, convirtiéndolo en segundos o agregándolo a otra datetime y datetime .

Esto devolverá un resultado negativo si la hora de finalización es anterior a la hora de inicio, por ejemplo, s1 = 12:00:00 y s2 = 05:00:00 . Si desea que el código suponga que el intervalo cruza la medianoche en este caso (es decir, debe suponer que la hora de finalización nunca es anterior a la hora de inicio), puede agregar las siguientes líneas al código anterior:

 if tdelta.days < 0: tdelta = timedelta(days=0, seconds=tdelta.seconds, microseconds=tdelta.microseconds) 

(por supuesto, debe incluir from datetime import timedelta algún lugar). Gracias a JF Sebastian por señalar este caso de uso.

Intente esto: es eficiente para progtwigr eventos a corto plazo. Si algo tarda más de una hora, entonces la pantalla final probablemente querrá un formato amigable.

 import time start = time.time() time.sleep(10) # or do something more productive done = time.time() elapsed = done - start print(elapsed) 

La diferencia de tiempo se devuelve como el número de segundos transcurridos.

La estructura que representa la diferencia de tiempo en Python se llama timedelta . Si tiene start_time y end_time como tipos de datetime y datetime , puede calcular la diferencia usando - operador como:

 diff = end_time - start_time 

debe hacer esto antes de convertir a un formato de cadena particualr (por ejemplo, antes de start_time.strftime (…)). En caso de que ya tenga una representación en cadena, deberá convertirla de nuevo a time / datetime utilizando el método strptime .

Aquí hay una solución que permite encontrar la diferencia, incluso si la hora de finalización es inferior a la hora de inicio (en el intervalo de medianoche), como 23:55:00-00:25:00 (una duración de media hora):

 #!/usr/bin/env python from datetime import datetime, time as datetime_time, timedelta def time_diff(start, end): if isinstance(start, datetime_time): # convert to datetime assert isinstance(end, datetime_time) start, end = [datetime.combine(datetime.min, t) for t in [start, end]] if start <= end: # eg, 10:33:26-11:15:49 return end - start else: # end < start eg, 23:55:00-00:25:00 end += timedelta(1) # +day assert end > start return end - start for time_range in ['10:33:26-11:15:49', '23:55:00-00:25:00']: s, e = [datetime.strptime(t, '%H:%M:%S') for t in time_range.split('-')] print(time_diff(s, e)) assert time_diff(s, e) == time_diff(s.time(), e.time()) 

Salida

 0:42:23 0:30:00 

time_diff() devuelve un objeto timedelta que puede pasar (como parte de la secuencia) a una función mean() directamente, por ejemplo:

 #!/usr/bin/env python from datetime import timedelta def mean(data, start=timedelta(0)): """Find arithmetic average.""" return sum(data, start) / len(data) data = [timedelta(minutes=42, seconds=23), # 0:42:23 timedelta(minutes=30)] # 0:30:00 print(repr(mean(data))) # -> datetime.timedelta(0, 2171, 500000) # days, seconds, microseconds 

El resultado de mean() también es el objeto timedelta() que puede convertir a segundos (método td.total_seconds() (desde Python 2.7)), horas ( td / timedelta(hours=1) (Python 3)), etc.

Me gusta cómo lo hace este tipo: https://amalgjose.com/2015/02/19/python-code-for-calculating-the-difference-between-two-time-stamps . No estoy seguro si tiene algunos inconvenientes.

Pero se ve bien para mí 🙂

 from datetime import datetime from dateutil.relativedelta import relativedelta t_a = datetime.now() t_b = datetime.now() def diff(t_a, t_b): t_diff = relativedelta(t_b, t_a) # later/end time comes first! return '{h}h {m}m {s}s'.format(h=t_diff.hours, m=t_diff.minutes, s=t_diff.seconds) 

Con respecto a la pregunta, usted todavía necesita usar datetime.strptime() como otros dijeron anteriormente.

Este sitio dice para probar:

 import datetime as dt start="09:35:23" end="10:23:00" start_dt = dt.datetime.strptime(start, '%H:%M:%S') end_dt = dt.datetime.strptime(end, '%H:%M:%S') diff = (end_dt - start_dt) diff.seconds/60 

Este foro usa time.mktime ()

Prueba esto

 import datetime import time start_time = datetime.datetime.now().time().strftime('%H:%M:%S') time.sleep(5) end_time = datetime.datetime.now().time().strftime('%H:%M:%S') total_time=(datetime.datetime.strptime(end_time,'%H:%M:%S') - datetime.datetime.strptime(start_time,'%H:%M:%S')) print total_time 

SALIDA:

 0:00:05 

Tanto la time como la datetime y datetime tienen un componente de fecha.

Normalmente, si solo se trata de la parte de tiempo, debe proporcionar una fecha predeterminada. Si solo está interesado en la diferencia y sabe que ambas horas son el mismo día, construya una datetime y datetime para cada una con el día establecido hoy y reste el inicio de la hora de timedelta para obtener el intervalo ( timedelta ).

Eche un vistazo al módulo datetime y los objetos timedelta. Deberías terminar construyendo un objeto de fecha y hora para las horas de inicio y finalización, y cuando los restas, obtienes un timedelta.

Conciso si solo está interesado en el tiempo transcurrido que es inferior a 24 horas. Puede formatear la salida según sea necesario en la statement de retorno:

 import datetime def elapsed_interval(start,end): elapsed = end - start min,secs=divmod(elapsed.days * 86400 + elapsed.seconds, 60) hour, minutes = divmod(min, 60) return '%.2d:%.2d:%.2d' % (hour,minutes,secs) if __name__ == '__main__': time_start=datetime.datetime.now() """ do your process """ time_end=datetime.datetime.now() total_time=elapsed_interval(time_start,time_end) 
 from datetime import datetime from datetime import timedelta T1 = input() T2 = input() format = '%H:%M' tdiff = datetime.strptime(T1, format) - datetime.strptime(T2, format) if tdiff.days < 0: tdiff = timedelta(days = 0, seconds = tdiff.seconds, microseconds = tdiff.microseconds) print(tdiff) 

Y el formato devuelto es H:MM:SS . ¿Es posible que llegue a HH:MM ? por ejemplo, 00:40 lugar de 0:40:00