Formater timedelta en chaîne

J'ai du mal à formater un datetime.timedeltaobjet.

Voici ce que j'essaie de faire: j'ai une liste d'objets et l'un des membres de la classe de l'objet est un objet timedelta qui montre la durée d'un événement. Je voudrais afficher cette durée au format heures: minutes.

J'ai essayé une variété de méthodes pour ce faire et j'ai des difficultés. Mon approche actuelle consiste à ajouter des méthodes à la classe pour mes objets qui renvoient des heures et des minutes. Je peux obtenir les heures en divisant le timedelta.seconds par 3600 et en l'arrondissant. J'ai du mal à obtenir les secondes restantes et à les convertir en minutes.

Soit dit en passant, j'utilise Google AppEngine avec les modèles Django pour la présentation.

Vous pouvez simplement convertir le timedelta en une chaîne avec str (). Voici un exemple:

import datetime
start = datetime.datetime(2009,2,10,14,00)
end   = datetime.datetime(2009,2,10,16,00)
delta = end-start
print(str(delta))
# prints 2:00:00

Comme vous le savez, vous pouvez obtenir le total_seconds d'un objet timedelta en accédant à l' .secondsattribut.

Python fournit la fonction intégrée divmod()qui permet:

s = 13420
hours, remainder = divmod(s, 3600)
minutes, seconds = divmod(remainder, 60)
print '{:02}:{:02}:{:02}'.format(int(hours), int(minutes), int(seconds))
# result: 03:43:40

ou vous pouvez convertir en heures et en reste en utilisant une combinaison de modulo et de soustraction:

# arbitrary number of seconds
s = 13420
# hours
hours = s // 3600 
# remaining seconds
s = s - (hours * 3600)
# minutes
minutes = s // 60
# remaining seconds
seconds = s - (minutes * 60)
# total time
print '{:02}:{:02}:{:02}'.format(int(hours), int(minutes), int(seconds))
# result: 03:43:40

>>> str(datetime.timedelta(hours=10.56))
10:33:36

>>> td = datetime.timedelta(hours=10.505) # any timedelta object
>>> ':'.join(str(td).split(':')[:2])
10:30

Passer l' timedeltaobjet à la str()fonction appelle le même code de mise en forme utilisé si nous tapons simplement print td. Puisque vous ne voulez pas des secondes, nous pouvons diviser la chaîne par deux points (3 parties) et la remettre ensemble avec seulement les 2 premières parties.

def td_format(td_object):
    seconds = int(td_object.total_seconds())
    periods = [
        ('year',        60*60*24*365),
        ('month',       60*60*24*30),
        ('day',         60*60*24),
        ('hour',        60*60),
        ('minute',      60),
        ('second',      1)
    ]

    strings=[]
    for period_name, period_seconds in periods:
        if seconds > period_seconds:
            period_value , seconds = divmod(seconds, period_seconds)
            has_s = 's' if period_value > 1 else ''
            strings.append("%s %s%s" % (period_value, period_name, has_s))

    return ", ".join(strings)

J'utilise personnellement la humanizebibliothèque pour cela:

>>> import datetime
>>> humanize.naturalday(datetime.datetime.now())
'today'
>>> humanize.naturalday(datetime.datetime.now() - datetime.timedelta(days=1))
'yesterday'
>>> humanize.naturalday(datetime.date(2007, 6, 5))
'Jun 05'
>>> humanize.naturaldate(datetime.date(2007, 6, 5))
'Jun 05 2007'
>>> humanize.naturaltime(datetime.datetime.now() - datetime.timedelta(seconds=1))
'a second ago'
>>> humanize.naturaltime(datetime.datetime.now() - datetime.timedelta(seconds=3600))
'an hour ago'

Bien sûr, cela ne vous donne pas exactement la réponse que vous cherchiez (ce qui est vrai, str(timeA - timeB)mais j'ai constaté qu'une fois que vous avez dépassé quelques heures, l'affichage devient rapidement illisible. Prend en humanizecharge des valeurs beaucoup plus grandes qui sont lisible par l'homme, et est également bien localisé.

Il est contrib.humanizeapparemment inspiré du module de Django , donc puisque vous utilisez Django, vous devriez probablement l'utiliser.

Il a déjà un objet timedelta, alors pourquoi ne pas utiliser sa méthode intégrée total_seconds () pour le convertir en secondes, puis utiliser divmod () pour obtenir les heures et les minutes?

hours, remainder = divmod(myTimeDelta.total_seconds(), 3600)
minutes, seconds = divmod(remainder, 60)

# Formatted only for hours and minutes as requested
print '%s:%s' % (hours, minutes)

Cela fonctionne peu importe si le delta de temps a même des jours ou des années.

Voici une fonction à usage général pour convertir un timedeltaobjet ou un nombre régulier (sous forme de secondes ou de minutes, etc.) en une chaîne bien formatée. J'ai pris la réponse fantastique de mpounsett sur une question en double, je l'ai rendue un peu plus flexible, amélioré la lisibilité et ajouté de la documentation.

Vous constaterez que c'est la réponse la plus flexible jusqu'ici car elle vous permet de:

1. Personnalisez le format de chaîne à la volée au lieu d'être codé en dur.
2. Laissez certains intervalles de temps sans problème (voir les exemples ci-dessous).

Fonction:

from string import Formatter
from datetime import timedelta

def strfdelta(tdelta, fmt='{D:02}d {H:02}h {M:02}m {S:02}s', inputtype='timedelta'):
    """Convert a datetime.timedelta object or a regular number to a custom-
    formatted string, just like the stftime() method does for datetime.datetime
    objects.

    The fmt argument allows custom formatting to be specified.  Fields can 
    include seconds, minutes, hours, days, and weeks.  Each field is optional.

    Some examples:
        '{D:02}d {H:02}h {M:02}m {S:02}s' --> '05d 08h 04m 02s' (default)
        '{W}w {D}d {H}:{M:02}:{S:02}'     --> '4w 5d 8:04:02'
        '{D:2}d {H:2}:{M:02}:{S:02}'      --> ' 5d  8:04:02'
        '{H}h {S}s'                       --> '72h 800s'

    The inputtype argument allows tdelta to be a regular number instead of the  
    default, which is a datetime.timedelta object.  Valid inputtype strings: 
        's', 'seconds', 
        'm', 'minutes', 
        'h', 'hours', 
        'd', 'days', 
        'w', 'weeks'
    """

    # Convert tdelta to integer seconds.
    if inputtype == 'timedelta':
        remainder = int(tdelta.total_seconds())
    elif inputtype in ['s', 'seconds']:
        remainder = int(tdelta)
    elif inputtype in ['m', 'minutes']:
        remainder = int(tdelta)*60
    elif inputtype in ['h', 'hours']:
        remainder = int(tdelta)*3600
    elif inputtype in ['d', 'days']:
        remainder = int(tdelta)*86400
    elif inputtype in ['w', 'weeks']:
        remainder = int(tdelta)*604800

    f = Formatter()
    desired_fields = [field_tuple[1] for field_tuple in f.parse(fmt)]
    possible_fields = ('W', 'D', 'H', 'M', 'S')
    constants = {'W': 604800, 'D': 86400, 'H': 3600, 'M': 60, 'S': 1}
    values = {}
    for field in possible_fields:
        if field in desired_fields and field in constants:
            values[field], remainder = divmod(remainder, constants[field])
    return f.format(fmt, **values)

Démo:

>>> td = timedelta(days=2, hours=3, minutes=5, seconds=8, microseconds=340)

>>> print strfdelta(td)
02d 03h 05m 08s

>>> print strfdelta(td, '{D}d {H}:{M:02}:{S:02}')
2d 3:05:08

>>> print strfdelta(td, '{D:2}d {H:2}:{M:02}:{S:02}')
 2d  3:05:08

>>> print strfdelta(td, '{H}h {S}s')
51h 308s

>>> print strfdelta(12304, inputtype='s')
00d 03h 25m 04s

>>> print strfdelta(620, '{H}:{M:02}', 'm')
10:20

>>> print strfdelta(49, '{D}d {H}h', 'h')
2d 1h

Je sais que c'est une vieille question à réponse, mais je l'utilise datetime.utcfromtimestamp()pour cela. Cela prend le nombre de secondes et retourne un datetimequi peut être formaté comme n'importe quel autre datetime.

duration = datetime.utcfromtimestamp(end - begin)
print duration.strftime('%H:%M')

Tant que vous restez dans les plages légales pour les parties de temps, cela devrait fonctionner, c'est-à-dire qu'il ne renvoie pas 1234: 35 car les heures sont <= 23.

Questioner veut un format plus agréable que le standard:

  >>> import datetime
  >>> datetime.timedelta(seconds=41000)
  datetime.timedelta(0, 41000)
  >>> str(datetime.timedelta(seconds=41000))
  '11:23:20'
  >>> str(datetime.timedelta(seconds=4102.33))
  '1:08:22.330000'
  >>> str(datetime.timedelta(seconds=413302.33))
  '4 days, 18:48:22.330000'

Donc, il y a vraiment deux formats, l'un où les jours sont 0 et il est omis, et l'autre où il y a du texte "n jours, h: m: s". Mais, les secondes peuvent avoir des fractions, et il n'y a pas de zéros de tête dans les impressions, donc les colonnes sont en désordre.

Voici ma routine, si vous l'aimez:

def printNiceTimeDelta(stime, etime):
    delay = datetime.timedelta(seconds=(etime - stime))
    if (delay.days > 0):
        out = str(delay).replace(" days, ", ":")
    else:
        out = "0:" + str(delay)
    outAr = out.split(':')
    outAr = ["%02d" % (int(float(x))) for x in outAr]
    out   = ":".join(outAr)
    return out

cela renvoie la sortie au format dd: hh: mm: ss:

00:00:00:15
00:00:00:19
02:01:31:40
02:01:32:22

J'ai pensé à ajouter des années à cela, mais cela reste un exercice pour le lecteur, car la sortie est sûre à plus d'un an:

>>> str(datetime.timedelta(seconds=99999999))
'1157 days, 9:46:39'

Je considérerais sérieusement l'approche du rasoir d'Occam ici:

td = str(timedelta).split('.')[0]

Cela renvoie une chaîne sans les microsecondes

Si vous souhaitez régénérer l'objet datetime.timedelta, procédez comme suit:

h,m,s = re.split(':', td)
new_delta = datetime.timedelta(hours=int(h),minutes=int(m),seconds=int(s))

Depuis 2 ans, j'adore cette langue!

Mes datetime.timedeltaobjets ont dépassé la journée. Voici donc un autre problème. Toute la discussion ci-dessus suppose moins d'une journée. A timedeltaest en fait un tuple de jours, de secondes et de microsecondes. La discussion ci-dessus devrait être utilisée td.secondscomme Joe l'a fait, mais si vous avez des jours, elle n'est PAS incluse dans la valeur des secondes.

Je reçois un intervalle de temps entre 2 heures et jours et heures d'impression.

span = currentdt - previousdt
print '%d,%d\n' % (span.days,span.seconds/3600)

J'ai utilisé la humanfriendlybibliothèque python pour cela, cela fonctionne très bien.

import humanfriendly
from datetime import timedelta
delta = timedelta(seconds = 321)
humanfriendly.format_timespan(delta)

'5 minutes and 21 seconds'

Disponible sur https://pypi.org/project/humanfriendly/

En suivant l'exemple de la valeur de Joe ci-dessus, j'utiliserais l'opérateur arithmétique du module, donc:

td = datetime.timedelta(hours=10.56)
td_str = "%d:%d" % (td.seconds/3600, td.seconds%3600/60)

Notez que la division entière en Python arrondit par défaut; si vous voulez être plus explicite, utilisez math.floor () ou math.ceil () selon le cas.

def seconds_to_time_left_string(total_seconds):
    s = int(total_seconds)
    years = s // 31104000
    if years > 1:
        return '%d years' % years
    s = s - (years * 31104000)
    months = s // 2592000
    if years == 1:
        r = 'one year'
        if months > 0:
            r += ' and %d months' % months
        return r
    if months > 1:
        return '%d months' % months
    s = s - (months * 2592000)
    days = s // 86400
    if months == 1:
        r = 'one month'
        if days > 0:
            r += ' and %d days' % days
        return r
    if days > 1:
        return '%d days' % days
    s = s - (days * 86400)
    hours = s // 3600
    if days == 1:
        r = 'one day'
        if hours > 0:
            r += ' and %d hours' % hours
        return r 
    s = s - (hours * 3600)
    minutes = s // 60
    seconds = s - (minutes * 60)
    if hours >= 6:
        return '%d hours' % hours
    if hours >= 1:
        r = '%d hours' % hours
        if hours == 1:
            r = 'one hour'
        if minutes > 0:
            r += ' and %d minutes' % minutes
        return r
    if minutes == 1:
        r = 'one minute'
        if seconds > 0:
            r += ' and %d seconds' % seconds
        return r
    if minutes == 0:
        return '%d seconds' % seconds
    if seconds == 0:
        return '%d minutes' % minutes
    return '%d minutes and %d seconds' % (minutes, seconds)

for i in range(10):
    print pow(8, i), seconds_to_time_left_string(pow(8, i))


Output:
1 1 seconds
8 8 seconds
64 one minute and 4 seconds
512 8 minutes and 32 seconds
4096 one hour and 8 minutes
32768 9 hours
262144 3 days
2097152 24 days
16777216 6 months
134217728 4 years

J'ai eu un problème similaire avec la sortie du calcul des heures supplémentaires au travail. La valeur doit toujours apparaître en HH: MM, même lorsqu'elle est supérieure à un jour et que la valeur peut devenir négative. J'ai combiné certaines des solutions présentées et peut-être que quelqu'un d'autre a trouvé cette solution utile. J'ai réalisé que si la valeur timedelta est négative, la plupart des solutions affichées avec la méthode divmod ne fonctionnent pas immédiatement:

def td2HHMMstr(td):
  '''Convert timedelta objects to a HH:MM string with (+/-) sign'''
  if td < datetime.timedelta(seconds=0):
    sign='-'
    td = -td
  else:
    sign = ''
  tdhours, rem = divmod(td.total_seconds(), 3600)
  tdminutes, rem = divmod(rem, 60)
  tdstr = '{}{:}:{:02d}'.format(sign, int(tdhours), int(tdminutes))
  return tdstr

timedelta à HH: MM chaîne:

td2HHMMstr(datetime.timedelta(hours=1, minutes=45))
'1:54'

td2HHMMstr(datetime.timedelta(days=2, hours=3, minutes=2))
'51:02'

td2HHMMstr(datetime.timedelta(hours=-3, minutes=-2))
'-3:02'

td2HHMMstr(datetime.timedelta(days=-35, hours=-3, minutes=-2))
'-843:02'

import datetime
hours = datetime.timedelta(hours=16, minutes=30)
print((datetime.datetime(1,1,1) + hours).strftime('%H:%M'))

Un filtre de modèle simple pour ce problème. La fonction intégrée int () n'est jamais arrondie. Les chaînes F (c'est-à-dire f '') nécessitent python 3.6.

@app_template_filter()
def diffTime(end, start):
    diff = (end - start).total_seconds()
    d = int(diff / 86400)
    h = int((diff - (d * 86400)) / 3600)
    m = int((diff - (d * 86400 + h * 3600)) / 60)
    s = int((diff - (d * 86400 + h * 3600 + m *60)))
    if d > 0:
        fdiff = f'{d}d {h}h {m}m {s}s'
    elif h > 0:
        fdiff = f'{h}h {m}m {s}s'
    elif m > 0:
        fdiff = f'{m}m {s}s'
    else:
        fdiff = f'{s}s'
    return fdiff

from django.utils.translation import ngettext

def localize_timedelta(delta):
    ret = []
    num_years = int(delta.days / 365)
    if num_years > 0:
        delta -= timedelta(days=num_years * 365)
        ret.append(ngettext('%d year', '%d years', num_years) % num_years)

    if delta.days > 0:
        ret.append(ngettext('%d day', '%d days', delta.days) % delta.days)

    num_hours = int(delta.seconds / 3600)
    if num_hours > 0:
        delta -= timedelta(hours=num_hours)
        ret.append(ngettext('%d hour', '%d hours', num_hours) % num_hours)

    num_minutes = int(delta.seconds / 60)
    if num_minutes > 0:
        ret.append(ngettext('%d minute', '%d minutes', num_minutes) % num_minutes)

    return ' '.join(ret)

Cela produira:

>>> from datetime import timedelta
>>> localize_timedelta(timedelta(days=3660, minutes=500))
'10 years 10 days 8 hours 20 minutes'

Veuillez vérifier cette fonction - il convertit l'objet timedelta en chaîne 'HH: MM: SS'

def format_timedelta(td):
    hours, remainder = divmod(td.total_seconds(), 3600)
    minutes, seconds = divmod(remainder, 60)
    hours, minutes, seconds = int(hours), int(minutes), int(seconds)
    if hours < 10:
        hours = '0%s' % int(hours)
    if minutes < 10:
        minutes = '0%s' % minutes
    if seconds < 10:
        seconds = '0%s' % seconds
    return '%s:%s:%s' % (hours, minutes, seconds)

Bon mot. Puisque les timedeltas n'offrent pas le strftime de datetime, ramenez le timedelta à un datetime et utilisez stftime.

Cela peut non seulement atteindre le format demandé par l'OP Heures: minutes, vous pouvez maintenant tirer parti de toute la puissance de formatage du strftime de datetime, si vos besoins changent en une autre représentation.

import datetime
td = datetime.timedelta(hours=2, minutes=10, seconds=5)
print(td)
print(datetime.datetime.strftime(datetime.datetime.strptime(str(td), "%H:%M:%S"), "%H:%M"))

Output:
2:10:05
02:10

Cela résout également la gêne que les timedeltas sont formatés en chaînes comme H: MM: SS plutôt que HH: MM: SS, ce qui m'amène à ce problème et à la solution que j'ai partagée.

Si vous avez déjà un obj timedelta, convertissez-le simplement en chaîne. Supprimez les 3 derniers caractères de la chaîne et imprimez. Cela tronquera la partie des secondes et imprimera le reste au format Heures: Minutes.

t = str(timedeltaobj) 

print t[:-3]

S'il vous arrive d'avoir IPythondans vos paquets (vous devriez), il a (jusqu'à présent, de toute façon) un très bon formateur pour les durées (en secondes flottantes). Cela est utilisé à divers endroits, par exemple par la %%timemagie cellulaire. J'aime le format qu'il produit pour de courtes durées:

>>> from IPython.core.magics.execution import _format_time
>>> 
>>> for v in range(-9, 10, 2):
...     dt = 1.25 * 10**v
...     print(_format_time(dt))

1.25 ns
125 ns
12.5 µs
1.25 ms
125 ms
12.5 s
20min 50s
1d 10h 43min 20s
144d 16h 13min 20s
14467d 14h 13min 20s

t1 = datetime.datetime.strptime(StartTime, "%H:%M:%S %d-%m-%y")

t2 = datetime.datetime.strptime(EndTime, "%H:%M:%S %d-%m-%y")

return str(t2-t1)

Donc pour:

StartTime = '15:28:53 21-07-13'
EndTime = '15:32:40 21-07-13'

Retour:

'0:03:47'

Merci à tous pour votre aide. J'ai pris bon nombre de vos idées et les ai rassemblées, faites-moi savoir ce que vous en pensez.

J'ai ajouté deux méthodes à la classe comme ceci:

def hours(self):
    retval = ""
    if self.totalTime:
        hoursfloat = self.totalTime.seconds / 3600
        retval = round(hoursfloat)
    return retval

def minutes(self):
    retval = ""
    if self.totalTime:
        minutesfloat = self.totalTime.seconds / 60
        hoursAsMinutes = self.hours() * 60
        retval = round(minutesfloat - hoursAsMinutes)
    return retval

Dans mon django, j'ai utilisé ceci (la somme est l'objet et elle est dans un dictionnaire):

<td>{{ sum.0 }}</td>    
<td>{{ sum.1.hours|stringformat:"d" }}:{{ sum.1.minutes|stringformat:"#02.0d" }}</td>