Como calcular o intervalo de tempo entre duas seqüências de tempo

Eu tenho duas vezes, uma hora de início e uma parada, no formato 10:33:26 (HH: MM: SS). Eu preciso da diferença entre os dois tempos. Estive pesquisando a documentação do Python e pesquisando on-line e imaginaria que isso teria algo a ver com os módulos datetime e / ou time. Não consigo fazê-lo funcionar corretamente e continuo descobrindo apenas como fazer isso quando há uma data envolvida.

Por fim, preciso calcular as médias de várias durações de tempo. Eu tenho as diferenças de horário para trabalhar e as estou armazenando em uma lista. Agora preciso calcular a média. Estou usando expressões regulares para analisar os horários originais e depois fazer as diferenças.

Para a média, devo converter para segundos e depois para a média?

Sim, definitivamente datetimeé o que você precisa aqui. Especificamente, a strptimefunção, que analisa uma string em um objeto de tempo.

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)

Isso gera um timedeltaobjeto que contém a diferença entre os dois tempos. Você pode fazer o que quiser com isso, por exemplo, convertendo-o em segundos ou adicionando-o a outro datetime.

Isso retornará um resultado negativo se o horário final for anterior ao horário de início, por exemplo, s1 = 12:00:00e s2 = 05:00:00. Se você quiser que o código assuma que o intervalo cruza a meia-noite nesse caso (ou seja, ele deve assumir que o horário final nunca é anterior ao horário de início), você pode adicionar as seguintes linhas ao código acima:

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

(é claro que você precisa incluir em from datetime import timedeltaalgum lugar). Agradecemos a JF Sebastian por apontar esse caso de uso.

Tente isso - é eficiente para sincronizar eventos de curto prazo. Se algo demorar mais de uma hora, a exibição final provavelmente precisará de uma formatação amigável.

import time
start = time.time()

time.sleep(10)  # or do something more productive

done = time.time()
elapsed = done - start
print(elapsed)

A diferença de tempo é retornada como o número de segundos decorridos.

Aqui está uma solução que suporta encontrar a diferença, mesmo que o horário final seja menor que o horário de início (no intervalo da meia-noite), como 23:55:00-00:25:00(meia hora de duração):

#!/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: # e.g., 10:33:26-11:15:49
        return end - start
    else: # end < start e.g., 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())

Resultado

0:42:23
0:30:00

time_diff()retorna um objeto timedelta que você pode passar (como parte da sequência) para uma mean()função diretamente, por exemplo:

#!/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

O mean()resultado também é um timedelta()objeto que você pode converter em segundos ( td.total_seconds()método (desde Python 2.7)), horas ( td / timedelta(hours=1)(Python 3)) etc.

A estrutura que representa a diferença horária no Python é chamada timedelta . Se você tem start_timee end_timecomo datetimetipos, pode calcular a diferença usando um -operador como:

diff = end_time - start_time

você deve fazer isso antes de converter para o formato de string particualr (por exemplo, antes de start_time.strftime (...)). Caso você já tenha uma representação de sequência, é necessário convertê-la novamente em time / datetime usando o método strptime .

Este site diz para tentar:

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 fórum usa time.mktime ()

Eu gosto de como esse cara faz isso - https://amalgjose.com/2015/02/19/python-code-for-calculating-the-difference-between-two-time-stamps . Não tenho certeza se tem alguns contras.

Mas parece arrumado para mim :)

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)

Em relação à pergunta, você ainda precisa usar datetime.strptime()como os outros disseram anteriormente.

Tente isto

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

RESULTADO :

0:00:05

import datetime as dt
from dateutil.relativedelta import relativedelta

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")
timedelta_obj = relativedelta(start_dt, end_dt)
print(
    timedelta_obj.years,
    timedelta_obj.months,
    timedelta_obj.days,
    timedelta_obj.hours,
    timedelta_obj.minutes,
    timedelta_obj.seconds,
)

resultado: 0 0 0 0 -47 -37

Ambos timee datetimetêm um componente de data.

Normalmente, se você estiver apenas lidando com a parte do tempo, fornecerá uma data padrão. Se você está interessado apenas na diferença e sabe que os dois horários são no mesmo dia, construa um datetimepara cada um com o dia definido para hoje e subtraia o início do horário de parada para obter o intervalo ( timedelta).

Dê uma olhada no módulo datetime e nos objetos timedelta. Você deve acabar construindo um objeto de data e hora para os horários de início e de término e, quando subtraí-los, obtém um intervalo de tempo.

Conciso, se você está interessado apenas no tempo decorrido inferior a 24 horas. Você pode formatar a saída conforme necessário na instrução 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)