web-dev-qa-db-fra.com

Comment calculer l'intervalle de temps entre deux chaînes de temps

J'ai deux fois, une heure de début et une heure de fin, au format 10:33:26 (HH: MM: SS). J'ai besoin de la différence entre les deux fois. J'ai parcouru la documentation de Python et effectué une recherche en ligne. J'imagine que cela aurait quelque chose à voir avec les modules datetime et/ou time. Je n'arrive pas à le faire fonctionner correctement et je n'arrive pas à trouver le moyen de le faire lorsqu'une date est impliquée.

En fin de compte, je dois calculer les moyennes de plusieurs durées. J'ai les différences de temps pour travailler et je les stocke dans une liste. Je dois maintenant calculer la moyenne. J'utilise des expressions régulières pour analyser les temps d'origine, puis faire les différences.

Pour la moyenne, devrais-je convertir en secondes puis en moyenne?

140
Hannah

Oui, définitivement datetime est ce dont vous avez besoin ici. Plus précisément, la fonction strptime, qui analyse une chaîne en un objet heure.

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)

Cela vous donne un objet timedelta qui contient la différence entre les deux fois. Vous pouvez faire ce que vous voulez avec ça, par exemple convertir en secondes ou l'ajouter à un autre datetime.

Cela retournera un résultat négatif si l'heure de fin est antérieure à l'heure de début, par exemple s1 = 12:00:00 et s2 = 05:00:00. Si vous souhaitez que le code présume que l’intervalle dépasse minuit dans ce cas (c’est-à-dire que l’heure de fin ne doit jamais être antérieure à l’heure de début), vous pouvez ajouter les lignes suivantes au code ci-dessus:

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

(bien sûr, vous devez inclure from datetime import timedelta quelque part). Merci à J.F. Sebastian d’avoir signalé ce cas d’utilisation.

177
David Z

Essayez ceci - il est efficace pour chronométrer des événements à court terme. Si quelque chose prend plus d'une heure, l'affichage final demandera probablement un formatage convivial.

import time
start = time.time()

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

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

La différence de temps est renvoyée sous forme de nombre de secondes écoulées.

130
Bill Grava

Voici une solution qui permet de trouver la différence même si l'heure de fin est inférieure à l'heure de début (sur un intervalle de minuit) telle que 23:55:00-00:25:00 (durée d'une demi-heure):

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

Sortie

0:42:23
0:30:00

time_diff() renvoie un objet timedelta que vous pouvez transmettre (en tant que partie de la séquence) à une fonction mean() directement, par exemple:

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

Le résultat mean() est également un objet timedelta() que vous pouvez convertir en secondes (méthode td.total_seconds() (depuis Python 2.7)), heure (td / timedelta(hours=1) (Python 3)), etc.

12
jfs

La structure qui représente la différence de temps dans Python s'appelle timedelta . Si vous avez start_time et end_time comme types datetime, vous pouvez calculer la différence à l'aide de l'opérateur - comme:

diff = end_time - start_time

vous devriez le faire avant de convertir au format de chaîne particulier (par exemple, avant start_time.strftime (...)). Si vous avez déjà une représentation sous forme de chaîne, vous devez la reconvertir en heure/date/heure en utilisant la méthode strptime .

10
dzida

This le site dit d'essayer:

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 

Ce forum utilise time.mktime ()

8
Kyra

J'aime la façon dont ce gars le fait - https://amalgjose.com/2015/02/19/python-code-for-calculating-the-difference-between-two-time-stamps . Je ne sais pas si ça a des inconvénients.

Mais ça a l'air chouette pour moi :)

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)

En ce qui concerne la question, vous devez toujours utiliser datetime.strptime() comme d'autres l'ont dit précédemment.

6
antonavy

Essaye ça

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

SORTIE:

0:00:05
3
Dipnesh Parakhiya

Les deux time et datetime ont un composant de date.

Normalement, si vous ne vous occupez que de la partie heure, vous devez fournir une date par défaut. Si vous êtes simplement intéressé par la différence et que vous savez que les deux heures sont identiques, construisez un datetime pour chacune avec le jour défini sur aujourd'hui et soustrayez le début de l'heure de fin pour obtenir l'intervalle (timedelta).

1
ChrisF

Jetez un coup d'œil au module datetime et aux objets timedelta. Vous devriez finir par construire un objet datetime pour les heures de début et de fin, et lorsque vous les soustrayez, vous obtenez un timedelta.

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

Et le format renvoyé est H:MM:SS. Est-il possible que je l'obtienne à HH:MM? Par exemple, 00:40 au lieu de 0:40:00

0
Amadeus

Concis si vous êtes simplement intéressé par le temps écoulé qui est inférieur à 24 heures. Vous pouvez formater la sortie selon vos besoins dans l'instruction 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 __== '__main__':
    time_start=datetime.datetime.now()
    """ do your process """
    time_end=datetime.datetime.now()
    total_time=elapsed_interval(time_start,time_end)
0
user2654744