Jak obliczyć odstęp czasu między dwoma ciągami czasu

Mam dwa czasy, czas rozpoczęcia i zakończenia, w formacie 10:33:26 (HH: MM: SS). Potrzebuję różnicy między tymi dwoma czasami. Przeglądałem dokumentację Pythona i szukałem w Internecie i wyobrażałem sobie, że ma to coś wspólnego z modułami datetime i / lub time. Nie mogę zmusić go do prawidłowego działania i znajduję tylko, jak to zrobić, gdy w grę wchodzi randka.

Ostatecznie muszę obliczyć średnie z wielu okresów czasu. Mam różnice czasu do pracy i przechowuję je na liście. Muszę teraz obliczyć średnią. Używam wyrażeń regularnych, aby przeanalizować oryginalne czasy, a następnie wprowadzić różnice.

Czy w celu uśrednienia należy przeliczyć na sekundy, a następnie uśrednić?

Tak, zdecydowanie datetimejest to, czego potrzebujesz tutaj. W szczególności strptimefunkcja, która analizuje ciąg znaków na obiekt czasu.

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)

Otrzymujesz timedeltaobiekt, który zawiera różnicę między dwoma czasami. Możesz z tym zrobić, co chcesz, np. Zamienić to na sekundy lub dodać do innego datetime.

Zwróci to wynik ujemny, jeśli czas zakończenia jest wcześniejszy niż czas rozpoczęcia, na przykład s1 = 12:00:00i s2 = 05:00:00. Jeśli chcesz, aby kod zakładał, że w tym przypadku interwał przekracza północ (tj. Powinien zakładać, że czas zakończenia nigdy nie jest wcześniejszy niż czas rozpoczęcia), możesz dodać następujące wiersze do powyższego kodu:

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

(oczywiście musisz from datetime import timedeltagdzieś dołączyć ). Podziękowania dla JF Sebastiana za wskazanie tego przypadku użycia.

Spróbuj tego - jest to skuteczne w przypadku krótkoterminowych wydarzeń. Jeśli coś zajmie więcej niż godzinę, ostateczny ekran prawdopodobnie będzie wymagał przyjaznego formatowania.

import time
start = time.time()

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

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

Różnica czasu jest zwracana jako liczba sekund, które upłynęły.

Oto rozwiązanie, które obsługuje znajdowanie różnicy, nawet jeśli czas zakończenia jest krótszy niż czas rozpoczęcia (powyżej północy), na przykład 23:55:00-00:25:00(pół godziny):

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

Wynik

0:42:23
0:30:00

time_diff()zwraca obiekt timedelta, który możesz przekazać (jako część sekwencji) mean()bezpośrednio do funkcji, np .:

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

mean()Wynik jest timedelta()obiektem, który można przekształcić do kilku sekund ( td.total_seconds()metoda (od Pythona 2,7)), godziny ( td / timedelta(hours=1)(Python 3)), itd.

Struktura reprezentująca różnicę czasu w Pythonie nosi nazwę timedelta . Jeśli masz start_timei end_timejako datetimetypy, możesz obliczyć różnicę za pomocą -operatora takiego jak:

diff = end_time - start_time

powinieneś to zrobić przed konwersją do konkretnego formatu łańcucha (np. przed start_time.strftime (...)). Jeśli masz już reprezentację ciągu, musisz przekonwertować ją z powrotem na czas / datę i godzinę za pomocą metody strptime .

Ta strona mówi, aby spróbować:

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 

To forum używa time.mktime ()

Podoba mi się, jak ten facet to robi - https://amalgjose.com/2015/02/19/python-code-for-calculating-the-difference-between-two-time-stamps . Nie jestem pewien, czy ma to jakieś wady.

Ale dla mnie wygląda schludnie :)

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)

Jeśli chodzi o pytanie, które musisz użyć, datetime.strptime()jak powiedzieli wcześniej inni.

Spróbuj tego

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

WYNIK :

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

wynik: 0 0 0 0 -47-37

Zarówno timeidatetime mają składnik daty.

Zwykle, jeśli masz do czynienia tylko z częścią czasową, podaj domyślną datę. Jeśli interesuje Cię tylko różnica i wiesz, że oba czasy są tego samego dnia, skonstruuj a datetimedla każdego z dniem ustawionym na dzień dzisiejszy i odejmij początek od czasu zakończenia, aby uzyskać interwał ( timedelta).

Przyjrzyj się modułowi datetime i obiektom timedelta. Powinieneś skończyć konstruowaniem obiektu daty i godziny dla czasów rozpoczęcia i zakończenia, a kiedy je odejmiesz, otrzymasz timedelta.

Zwięzłe, jeśli interesuje Cię tylko upływający czas poniżej 24 godzin. Możesz sformatować dane wyjściowe zgodnie z potrzebami w instrukcji return:

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)