Formater timedelta en chaîne

275

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.

mawcs
la source
44
Ce serait bien si timedelta avait un équivalent de la méthode strftime ().
JS.
@JS. Eh bien, vous pouvez un peu si vous utilisez datetime.utcfromtimestamp(). Voir ma réponse ci-dessous.
sjngm
@JS. - 100% d'accord. Ensuite, __str__de timedeltaest tout à fait décent, contrairement à __repr__(c'est-à-dire - pour les humains!). Par exemple: datetime.timedelta(minutes=6, seconds=41) * 2618 / 48donne datetime.timedelta(seconds=21871, microseconds=208333), mais str(datetime.timedelta(minutes=6, seconds=41) * 2618 / 48)donne '6:04:31.208333'ce qui est assez correct à lire.
Tomasz Gandor

Réponses:

213

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
Parand
la source
13
Plus comme appeler la méthode str () avec timedelta comme argument.
joeforker
12
Vous n'avez pas besoin de l'appel str ici, cela se fera automatiquement par impression.
Zitrax
5
@Zitrax mais c'est nécessaire si vous allez concaténer le delta avec une autre chaîne. Par exempleprint 'some thing ' + str(delta)
Plinio.Santos
13
Et nécessaire lorsque le type de données est défini comme 'datetime.timedelta' et que vous l'utilisez comme ceci, ConvertDuration=datetime.timedelta(milliseconds=int(254459))vous utilisez simplement le fractionnement pour retirer les microsecondes du jeu. De 0: 03: 43.765000 je peux obtenir 0:03:43 en exécutant simplementTotalDuration=str(ConvertDuration).split('.', 2)[0]
DarkXDroid
16
Cela pourrait imprimer le delta sous forme de chaîne, mais il ne le formate pas comme l'OP demandé.
Dannid
187

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
John Fouhy
la source
5
Pour les horaires négatifs, vous devez d'abord évaluer le signe, puis le faire abs(s).
mbarkhau
27
Notez que vous souhaiterez peut-être utiliser '%d:%02d:%02d'des zéros non significatifs dans la chaîne de sortie.
ShinNoNoir
12
pour python 2.7 et supérieur, utilisez la méthode .total_seconds ()
sk8asd123
27
Ne pas utiliser .secondssi la différence peut être négative ou supérieure à 24 heures (l' .secondsattribut ignore .days). Utilisez .total_seconds()ou son analogue à la place.
jfs
Pour les différences positives, je ré-implémente cela de temps en temps. Merci d'avoir juste cherché cette fois :)
Wolf
59
>>> 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.

joeforker
la source
Merci pour votre réponse joeforker, mais je ne suis pas sûr de comprendre votre réponse. J'obtiens un delta temporel par le biais de datetime - datetime. Je ne connais pas les heures. De plus, il semble que votre exemple inclut des secondes, comment pourrais-je supprimer cela?
mawcs
1
Peu importe où vous obtenez l'objet timedelta, il formatera le même.
joeforker
9
S'il est plus long qu'un jour, il se formera comme par exemple "4 jours, 8h00" après le traitement de la division / jointure.
joeforker
4
str(my_timedelta)fonctionne mal pour les nombres négatifs
Catskul
2
Affiche également les jours lorsque> 24 heures, par exemple '4 jours, 18: 48: 22.330000'. De nombreuses méthodes conseillées ici ne le font pas.
Alexei Martianov
47
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)
Adam Jacob Muller
la source
3
Vraiment sympa, je suggérerais cependant if seconds > period_seconds:de changer if seconds >= period_seconds:.
CBenni
1
Cela renvoie des chaînes vides pour les timedeltas négatifs, vous ne savez pas si cela est prévu?
Dirk
31

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.

anarcat
la source
2
Nice, + 1 Bien que: humanize.naturaldelta (pd.Timedelta ('- 10sec')) -> '10 seconds ': S ...
ntg
2
et il est de 10 secondes delta . :) si vous voulez le temps , naturaltimec'est ce que vous voulez utiliser.
anarcat
28

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.

Bill Kidd
la source
23

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
MarredCheese
la source
Très beau code propre! Je me demande comment ce code peut être étendu pour gérer les dernières secondes fractionnaires restantes dans le formateur ...
kfmfe04
17

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.

sjngm
la source
2
vous devez utiliser à la print timedelta(seconds=end - begin)place.
jfs
@JFSebastian Ensuite, vous devez remplir manuellement les heures avec des zéros non significatifs.
sjngm
Je ne vois rien sur le rembourrage dans la question. À utiliser .zfill(8)si vous en avez besoin.
jfs
1
Nécessite un appel .total_seconds (): >>> datetime.utcfromtimestamp ((t2-t1) .total_seconds ()). Strftime ("% H:% M:% S") <<< >>> '00: 00: 05 '
cagney
2
Je préfère de beaucoup cette solution, elle vous permet de contrôler le formatage. Notez que vous pouvez également utiliser le formateur str directement comme ceci: "{0:% H}: {0:% M}". Format (duration)
toes
15

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'
Kevin J. Rice
la source
15

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!

Pyrotherm
la source
5
Cela ne couvre pas les jours
Waschbaer
13

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)
Alex L
la source
Ceci est la solution à l'épreuve du temps.
Jibin
11

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/

Dhiraj Gupta
la source
7

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.

UltraNurd
la source
timedelta sait déjà se formater, comme dans 'print some_timedelta'.
joeforker
Oui, mais il ne peut pas accepter une chaîne de format arbitraire, c'est ce que Michael demandait. Bien que maintenant que j'y pense, le mod de division 3600 fait l'hypothèse d'heures-secondes qui provoque des problèmes en quelques secondes.
UltraNurd
Oui, mais il ne veut pas d'une chaîne de format arbitraire, il veut presque exactement le comportement par défaut.
joeforker
2
N'oubliez pas // pour tronquer la division en Python 3000
joeforker
3
+1, mais pourquoi ne modifiez-vous pas la réponse pour utiliser //? Je suggère également d'utiliser td.total_seconds()au lieu de .secondsle faire fonctionner pour des intervalles> 1 jour.
Antony Hatchkins
4
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
Veselin Penev
la source
Avez-vous écrit celui-ci? Combien l'avez-vous testé?
Thomas Ahle
J'utilise ce code dans mon projet appelé datahaven.net . Cela fonctionne très bien. Avez-vous vu des erreurs?
Veselin Penev
C'est toujours bien si vous pouvez fournir un peu d'informations avec une réponse aussi lourde de code :) Comme un exemple de comment cela fonctionne, les forces et les faiblesses possibles.
Thomas Ahle
1
Oh. Sûr!. Ajout d'un exemple pour vous. :-)
Veselin Penev
Super :) Notez également que l' timedeltaobjet a les champs days, secondset microsecondspar la documentation.
Thomas Ahle
4

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'
nealtz
la source
4
import datetime
hours = datetime.timedelta(hours=16, minutes=30)
print((datetime.datetime(1,1,1) + hours).strftime('%H:%M'))
SleX
la source
2
dans 3.7 j'obtiens AttributeError: l'objet 'datetime.timedelta' n'a pas d'attribut 'strftime'
qubodup
4

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
Patrick
la source
3
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'
Artem Vasilev
la source
Le plus joli à mon avis, en termes de durée et de ce qu'il couvre
Dici
1

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)
MobilePro.pl
la source
1

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.

Bill Gale
la source
0

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]
Sima
la source
Le -3 ne fonctionne pas, mieux l'utiliserprint t.split('.')[0]
EvgenyKolyakov
0

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
Pierre D
la source
-3
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'
Aviad
la source
-10

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>
mawcs
la source
C'est un peu long. Je suggère: def hhmm (self): return ':'. Join (str (td) .split (':') [: 2]) <td> {{sum.1.hhmm}} </td>
joeforker
1
Utilisez simplement divmod () comme indiqué dans l'exemple "Différence de deux dates" sur docs.python.org/release/2.5.2/lib/datetime-timedelta.html
Tom