Hoe het tijdsinterval tussen twee tijdreeksen te berekenen

Ik heb twee tijden, een start- en een stoptijd, in het formaat 10:33:26 (UU:MM:SS). Ik heb het verschil tussen de twee tijden nodig. Ik heb de documentatie voor Python doorgenomen en online gezocht en ik kan me voorstellen dat het iets te maken heeft met de datetime- en/of tijdmodules. Ik krijg het niet goed werkend en blijf alleen vinden hoe ik dit moet doen als er een date bij betrokken is.

Uiteindelijk moet ik de gemiddelden van meerdere tijdsduren berekenen. Ik heb de tijdsverschillen laten werken en ik sla ze op in een lijst. Ik moet nu het gemiddelde berekenen. Ik gebruik reguliere expressies om de oorspronkelijke tijden te ontleden en vervolgens de verschillen te maken.

Moet ik voor de middeling converteren naar seconden en dan gemiddeld?

Antwoord 1, autoriteit 100%

Ja, zeker datetimeis wat je hier nodig hebt . In het bijzonder de methode datetime.strptime(), die een string ontleedt in een datetime-object.

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)

Je krijgt dan een timedeltaobject dat het verschil tussen de twee tijden bevat. Daar kun je mee doen wat je wilt, b.v. converteren naar secondenof toevoegen aan een andere datetime.

Dit geeft een negatief resultaat als de eindtijd vroeger is dan de starttijd, bijvoorbeeld s1 = 12:00:00en s2 = 05:00:00. Als u wilt dat de code in dit geval aanneemt dat het interval middernacht overschrijdt (d.w.z. dat de eindtijd nooit eerder is dan de begintijd), kunt u de volgende regels aan de bovenstaande code toevoegen:

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

(natuurlijk moet je ergens from datetime import timedeltaopnemen). Met dank aan J.F. Sebastian voor het wijzen op deze use case.

Antwoord 2, autoriteit 78%

Probeer dit: het is efficiënt voor het timen van kortetermijngebeurtenissen. Als iets meer dan een uur duurt, zal de uiteindelijke weergave waarschijnlijk een vriendelijke opmaak nodig hebben.

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

Het tijdsverschil wordt geretourneerd als het aantal verstreken seconden.

Antwoord 3, autoriteit 7%

Hier is een oplossing die het vinden van het verschil ondersteunt, zelfs als de eindtijd korter is dan de starttijd (na middernacht), zoals 23:55:00-00:25:00(een halve een uur duur):

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

Uitgang

0:42:23
0:30:00

time_diff()retourneert een timedelta-object dat u (als een deel van de sequentie) kunt doorgeven aan een mean()-functie direct b.v.:

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

De mean()resultaat is ook timedelta()object die u kunt converteren naar seconden (td.total_seconds()methode (sindsdien Python 2.7)), uren (td / timedelta(hours=1)(Python 3)), enz.

4, Autoriteit 6%

Deze site zegt tegen probeer:

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 

Dit forumgebruikt time.mktime ()

Antwoord 5, autoriteit 5%

Structuur die het tijdsverschil in Python weergeeft, wordt timedeltagenoemd. Als u start_timeen end_timeals datetime-typen heeft, kunt u het verschil berekenen met behulp van de operator -zoals:

diff = end_time - start_time

u moet dit doen voordat u converteert naar een bepaalde tekenreeksindeling (bijv. vóór start_time.strftime(…)). Als je al een tekenreeksrepresentatie hebt, moet je deze terug converteren naar time/datetime met behulp van strptimemethode.

Antwoord 6, autoriteit 4%

Ik vind het leuk hoe deze man het doet — https://amalgjose.com/2015/02/19/python-code-for-calculating-the-difference-between-two-time-stamps.
Ik weet niet zeker of het nadelen heeft.

Maar ziet er netjes uit voor mij 🙂

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)

Wat betreft de vraag moet je nog steeds datetime.strptime()gebruiken zoals anderen al eerder zeiden.

Antwoord 7, autoriteit 2%

Probeer dit

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

UITGANG :

0:00:05

Antwoord 8, autoriteit 2%

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

resultaat:
0 0 0 0 -47 -37

Antwoord 9

Zowel timeals datetimehebben een datumcomponent.

Normaal gesproken, als u alleen met het tijdsdeel te maken heeft, geeft u een standaarddatum op. Als je alleen geïnteresseerd bent in het verschil en weet dat beide tijden op dezelfde dag vallen, maak dan een datetimevoor elk met de dag ingesteld op vandaag en trek de start van de stoptijd af om het interval te krijgen ( timedelta).

10

   import datetime
    day = int(input("day[1,2,3,..31]: "))
    month = int(input("Month[1,2,3,...12]: "))
    year = int(input("year[0~2020]: "))
    start_date = datetime.date(year, month, day)
    day = int(input("day[1,2,3,..31]: "))
    month = int(input("Month[1,2,3,...12]: "))
    year = int(input("year[0~2020]: "))
    end_date = datetime.date(year, month, day)
    time_difference = end_date - start_date
    age = time_difference.days
    print("Total days: " + str(age))

11

Beknopt als u gewoon geïnteresseerd bent in de verstreken tijd die jonger is dan 24 uur. U kunt de uitvoer indien nodig opmaken in de retourverklaring:

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)