Форматировать timedelta в строку

275

У меня проблемы с форматированием datetime.timedeltaобъекта.

Вот что я пытаюсь сделать: у меня есть список объектов, и один из членов класса объекта - это объект timedelta, который показывает продолжительность события. Я хотел бы отобразить эту продолжительность в формате часов: минут.

Я испробовал множество способов сделать это, и у меня возникли трудности. Мой текущий подход заключается в добавлении методов в класс для моих объектов, которые возвращают часы и минуты. Я могу получить часы, разделив timedelta.seconds на 3600 и округлив его. У меня проблемы с получением оставшихся секунд и преобразованием их в минуты.

Кстати, я использую Google AppEngine с шаблонами Django для презентации.

mawcs
источник
44
Было бы неплохо, если бы у timedelta был эквивалент метода strftime ().
JS.
@JS. Ну, вы можете, если вы используете datetime.utcfromtimestamp(). Смотрите мой ответ ниже.
sjngm
@JS. - 100% согласен. Тогда __str__из timedeltaвполне приличных, в отличие от __repr__(то есть - для людей). Например: datetime.timedelta(minutes=6, seconds=41) * 2618 / 48дает datetime.timedelta(seconds=21871, microseconds=208333), но str(datetime.timedelta(minutes=6, seconds=41) * 2618 / 48)дает, '6:04:31.208333'что вполне нормально читать.
Томаш Гандор

Ответы:

213

Вы можете просто преобразовать timedelta в строку с помощью str (). Вот пример:

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
источник
13
Больше похоже на вызов метода str () с timedelta в качестве аргумента.
Joeforker
12
Вам не нужен вызов str, это будет сделано автоматически при печати.
Цитракс
5
@Zitrax, но это необходимо, если вы собираетесь объединить дельту с другой строкой. Напримерprint 'some thing ' + str(delta)
Plinio.Santos
13
И это необходимо, когда тип данных определен как datetime.timedelta, и вы используете его вот так, ConvertDuration=datetime.timedelta(milliseconds=int(254459))тогда вы просто используете split, чтобы вывести микросекунды из игры. С 0: 03: 43.765000 я могу получить 0:03:43 , просто запустивTotalDuration=str(ConvertDuration).split('.', 2)[0]
DarkXDroid
16
Это может вывести дельту в виде строки, но она не отформатирует ее как запрошенный OP.
Даннид
187

Как вы знаете, вы можете получить total_seconds из объекта timedelta, обратившись к .secondsатрибуту.

Python предоставляет встроенную функцию, divmod()которая позволяет:

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

или вы можете преобразовать в часы и остаток, используя комбинацию по модулю и вычитанию:

# 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
Джон Фухи
источник
5
Для отрицательных значений времени вы должны сначала оценить знак, а затем сделать abs(s).
mbarkhau
27
Обратите внимание, что вы можете использовать '%d:%02d:%02d'начальные нули в выходной строке.
ShinNoNoir
12
для python 2.7 и выше используйте метод .total_seconds ()
sk8asd123
27
Не используйте, .secondsесли разница может быть отрицательной или более 24 часов ( .secondsатрибут игнорируется .days). Используйте .total_seconds()или его аналог вместо.
Jfs
Для положительных различий я время от времени повторяю это. Спасибо за то, что мне пришлось искать в этот раз :)
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

Передача timedeltaобъекта в str()функцию вызывает тот же код форматирования, который используется, если мы просто печатаем print td. Поскольку вам не нужны секунды, мы можем разделить строку на двоеточия (3 части) и соединить ее вместе только с первыми 2 частями.

joeforker
источник
Спасибо за ваш ответ joeforker, но я не уверен, что понимаю ваш ответ. Я получаю дельту времени посредством datetime - datetime. Я не знаю часов. Кроме того, похоже, ваш пример включает в себя секунды, как бы я это убрал?
mawcs
1
Неважно, где вы получите объект timedelta, он будет отформатирован одинаково.
Joeforker
9
Если он длиннее дня, он будет форматироваться как, например, «4 дня, 8:00» после обработки разделения / объединения.
Joeforker
4
str(my_timedelta)плохо работает для отрицательных чисел
Catskul
2
Показывает также дни, когда> 24 часа, например, «4 дня, 18: 48: 22.330000». Многие методы, рекомендованные здесь, не делают.
Алексей Мартианов
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)
Адам Джейкоб Мюллер
источник
3
Действительно хороший, я хотел бы предложить изменения if seconds > period_seconds:к if seconds >= period_seconds:однако.
CBenni
1
Это возвращает пустые строки для отрицательных timedeltas, не уверены, что это задумано?
Дирк
31

Я лично использую humanizeбиблиотеку для этого:

>>> 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'

Конечно, он не дает вам именно тот ответ, который вы искали (что действительно так, str(timeA - timeB)но я обнаружил, что по прошествии нескольких часов экран становится быстро нечитаемым), humanizeимеет поддержку гораздо больших значений, которые удобочитаемый, а также хорошо локализован.

По- contrib.humanizeвидимому, он вдохновлен модулем Django , поэтому, поскольку вы используете Django, вам, вероятно, следует его использовать.

anarcat
источник
2
Хорошо, + 1 Хотя: humanize.naturaldelta (pd.Timedelta ('- 10sec')) -> '10 секунд': S ...
ntg
2
ну это 10 секунд дельты . :) это вы хотите время , naturaltimeэто то , что вы хотите использовать.
anarcat
28

У него уже есть объект timedelta, так почему бы не использовать его встроенный метод total_seconds () для преобразования его в секунды, а затем использовать divmod () для получения часов и минут?

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)

Это работает независимо от того, имеет ли дельта времени четные дни или годы.

Билл Кидд
источник
23

Вот функция общего назначения для преобразования либо timedeltaобъекта, либо обычного числа (в виде секунд, минут и т. Д.) В красиво отформатированную строку. Я взял фантастический ответ mpounsett на дубликат вопроса, сделал его немного более гибким, улучшил удобочитаемость и добавил документацию.

Вы найдете, что это самый гибкий ответ здесь, поскольку он позволяет вам:

  1. Настраивайте формат строки на лету, а не жестко кодируйте ее.
  2. Оставьте определенные промежутки времени без проблем (см. Примеры ниже).

Функция:

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)

Демо-версия:

>>> 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
источник
Очень хороший, чистый код! Интересно, как этот код можно расширить, чтобы обработать последние доли секунды в
формататоре
17

Я знаю, что это старый ответ на вопрос, но я использую datetime.utcfromtimestamp()для этого. Он занимает количество секунд и возвращает значение, datetimeкоторое можно отформатировать, как и любое другое datetime.

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

Пока вы находитесь в допустимых пределах для временных интервалов, это должно работать, то есть оно не возвращает 1234: 35, поскольку часы <= 23.

sjngm
источник
2
Вы должны использовать print timedelta(seconds=end - begin)вместо этого.
Jfs
@JFSebastian Тогда вам придется вручную дополнять часы начальными нулями.
sjngm
Я не вижу ничего о заполнении в вопросе. Используйте, .zfill(8)если вам это нужно.
Jfs
1
Требуется вызов .total_seconds (): >>> datetime.utcfromtimestamp ((t2-t1) .total_seconds ()). Strftime ("% H:% M:% S") <<< >>> '00: 00: 05 '
Cagney
2
Я очень предпочитаю это решение, оно позволяет вам контролировать форматирование. Обратите внимание , вы можете также использовать ул форматировщик непосредственно , как это: "{0:% H}: {0:% M}" формат (продолжительность).
пальцы
15

Спрашивающий хочет более хороший формат, чем типичный:

  >>> 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'

Итак, на самом деле есть два формата: один, где дни равны 0, и он пропущен, а другой, где есть текст «n дней, ч: м: с». Но у секунд могут быть дроби, и в распечатках нет начальных нулей, поэтому столбцы грязные.

Вот моя рутина, если вам это нравится:

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

возвращает результат в формате дд: чч: мм: сс:

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

Я действительно думал о том, чтобы добавить к этому годы, но это оставлено читателю как упражнение, так как результат более 1 года:

>>> str(datetime.timedelta(seconds=99999999))
'1157 days, 9:46:39'
Кевин Дж. Райс
источник
15

Я серьезно рассмотрел бы подход Бритвы Оккама здесь:

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

Это возвращает строку без микросекунд

Если вы хотите восстановить объект datetime.timedelta, просто сделайте это:

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

2 года я люблю этот язык!

Pyrotherm
источник
5
Это не распространяется на дни
Waschbaer
13

Мои datetime.timedeltaобъекты пошли больше, чем за день. Так что вот еще одна проблема. Все обсуждение выше предполагает менее одного дня. А timedeltaна самом деле это кортеж дней, секунд и микросекунд. Приведенное выше обсуждение следует использовать так, td.secondsкак это делал Джо, но если у вас есть дни, оно НЕ включается в значение секунд.

Я получаю промежуток времени между двумя датами и печатными днями и часами.

span = currentdt - previousdt
print '%d,%d\n' % (span.days,span.seconds/3600)
Алекс Л
источник
Это будущее решение.
Джибин
11

Для этого я использовал humanfriendlyбиблиотеку python, она работает очень хорошо.

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

'5 minutes and 21 seconds'

Доступно по адресу https://pypi.org/project/humanfriendly/

Дирадж Гупта
источник
7

Следуя приведенному выше примеру Джо, я бы использовал арифметический оператор модуля:

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

Обратите внимание, что целочисленное деление в Python округляется по умолчанию; если вы хотите быть более явным, используйте math.floor () или math.ceil () в зависимости от ситуации.

UltraNurd
источник
timedelta уже знает, как форматировать себя, как в 'print some_timedelta'.
Joeforker
Да, но он не может принять произвольную строку формата, о чем просил Майкл. Хотя теперь, когда я об этом думаю, мод деления 3600 делает предположение о часах-секундах, что вызывает проблемы в високосные секунды.
UltraNurd
Да, но он не хочет произвольной строки формата, он хочет почти точно поведение по умолчанию.
Joeforker
2
Не забудьте // об урезании деления в Python 3000
joeforker
3
+1, но почему бы вам не отредактировать ответ, чтобы использовать //? Я бы также предложил использовать td.total_seconds()вместо того, .secondsчтобы заставить его работать с интервалами> 1 дня.
Энтони Хэтчкинс
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
Веселин Пенев
источник
Ты написал это? Сколько ты это тестировал?
Томас Але
Я использую этот код в моем проекте под названием datahaven.net . Это работает довольно хорошо. Вы видели какие-либо ошибки?
Веселин Пенев
Всегда приятно, если вы можете предоставить немного информации с таким тяжелым ответом кода :) Как пример того, как это работает, возможные сильные и слабые стороны.
Томас Ахл
1
Ой. Конечно!. Добавил пример для вас. :-)
Веселин Пенев
Супер :) Также обратите внимание , что timedeltaобъект имеет поле days, secondsи microsecondsв документации.
Томас Але
4

У меня была похожая проблема с выводом расчета сверхурочных на работе. Значение всегда должно отображаться в формате ЧЧ: ММ, даже если оно больше одного дня, и значение может стать отрицательным. Я объединил некоторые из показанных решений, и, возможно, кто-то найдет это решение полезным. Я понял, что если значение timedelta является отрицательным, большинство показанных решений с помощью метода divmod не работают из коробки:

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 в чч: мм строка:

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
источник
4
import datetime
hours = datetime.timedelta(hours=16, minutes=30)
print((datetime.datetime(1,1,1) + hours).strftime('%H:%M'))
Slex
источник
2
в 3.7 я получаю AttributeError: у объекта «datetime.timedelta» нет атрибута «strftime»
qubodup
4

Прямой шаблонный фильтр для этой проблемы. Встроенная функция int () никогда не округляется. F-строки (то есть f '') требуют 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
Патрик
источник
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)

Это даст:

>>> from datetime import timedelta
>>> localize_timedelta(timedelta(days=3660, minutes=500))
'10 years 10 days 8 hours 20 minutes'
Артем Васильев
источник
На мой взгляд, самый близкий по длине и
охвату
1

Пожалуйста, проверьте эту функцию - она ​​преобразует объект timedelta в строку «ЧЧ: ММ: СС»

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
источник
1

Один лайнер. Так как timedelt не предлагает strftime для datetime, верните timedelta к datetime и используйте stftime.

Это может не только обеспечить запрошенный формат OP. Часы: минуты, теперь вы можете использовать все возможности форматирования strftime datetime, если ваши требования изменятся на другое представление.

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

Это также устраняет раздражение от того, что временные интервалы форматируются в строки как H: MM: SS, а не HH: MM: SS, что приводит меня к этой проблеме и решению, которым я поделился.

Билл Гейл
источник
0

Если у вас уже есть timedelta obj, просто преобразуйте этот объект в строку. Удалите последние 3 символа строки и напечатайте. Это обрезает часть секунд и печатает оставшуюся часть в формате Часы: минуты.

t = str(timedeltaobj) 

print t[:-3]
Сима
источник
-3 не работает, лучше использоватьprint t.split('.')[0]
ЕвгенийКоляков
0

Если IPythonв ваших пакетах есть (вы должны это сделать), он имеет (до сих пор, во всяком случае) очень хороший форматер для длительностей (в секундах с плавающей запятой). Это используется в различных местах, например, %%timeмагией клеток. Мне нравится формат, который он производит на короткие промежутки времени:

>>> 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
Пьер Д
источник
-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)

Таким образом, для:

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

возвращает:

'0:03:47'
Aviad
источник
-10

Спасибо всем за вашу помощь. Я взял много твоих идей и соединил их, дай мне знать, что ты думаешь.

Я добавил в класс два метода:

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

В моем django я использовал это (сумма - объект, и это находится в словаре):

<td>{{ sum.0 }}</td>    
<td>{{ sum.1.hours|stringformat:"d" }}:{{ sum.1.minutes|stringformat:"#02.0d" }}</td>
mawcs
источник
Это немного долго. Я бы предложил: def hhmm (self): return ':'. Join (str (td) .split (':') [: 2]) <td> {{sum.1.hhmm}} </ td>
Joeforker
1
Просто используйте divmod (), как показано в примере «Разница двух дат» на docs.python.org/release/2.5.2/lib/datetime-timedelta.html
Том