Відформатуйте timedelta в рядок

У мене проблеми з форматуванням datetime.timedeltaоб'єкта.

Ось що я намагаюся зробити: у мене є список об’єктів, і один з членів класу об'єкта - це об'єкт timedelta, який показує тривалість події. Я хотів би відобразити цю тривалість у форматі годин: хвилин.

Я спробував різноманітні методи для цього, і у мене виникають труднощі. Мій сучасний підхід - додати методи до класу для моїх об'єктів, які повертають години та хвилини. Я можу отримати години, поділивши timedelta.seconds на 3600 і округливши його. У мене виникають проблеми з отриманням залишків секунд і перетворенням їх у хвилини.

До речі, я використовую Google AppEngine з шаблонами Django для презентації.

Ви можете просто перетворити 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

Як відомо, ви можете отримати 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

>>> 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 частин.

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)

Я особисто використовую 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, ви, ймовірно, повинні ним користуватися.

У нього вже є об'єкт 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)

Це працює незалежно від того, якщо в дельті часу є навіть дні чи роки.

Ось функція загального призначення для перетворення 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

Я знаю, що це старе відповідь на питання, але я використовую datetime.utcfromtimestamp()для цього. Це займає кількість секунд і повертає той, datetimeякий можна відформатувати, як і будь-який інший datetime.

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

Поки ви залишаєтесь у межах закону протягом певного часу, це має працювати, тобто воно не повертається 1234: 35, оскільки години <= 23.

Запитуючий бажає кращого формату, ніж типовий:

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

це повертає вихід у вигляді dd: hh: mm: ss формат:

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'

Я б серйозно подумав про підхід Оккама до бритва тут:

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 роки в, я люблю цю мову!

Мої datetime.timedeltaоб’єкти пішли більше, ніж за день. Тож тут подальша проблема. Все обговорення вище займає менше доби. A timedeltaнасправді є кількість днів, секунд та мікросекунд. Вищенаведене обговорення повинно використовуватись td.secondsяк Джо, але якщо у вас є дні, це НЕ включено у значення секунд.

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

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

Для цього я використав 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/

Виходячи з наведеного вище прикладу Джо, я б використав арифметичний оператор модуля, таким чином:

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

Зауважте, що ціле ділення в Python за замовчуванням округляється; якщо ви хочете бути більш чіткими, використовуйте math.floor () або math.ceil () у відповідних випадках.

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

У мене була схожа проблема з результатами розрахунку понаднормових робіт на роботі. Значення завжди повинно відображатися в HH: MM, навіть коли воно більше одного дня і значення може отримати негативне значення. Я поєднав деякі з показаних рішень і, можливо, хтось інший вважає це рішення корисним. Я зрозумів, що якщо значення 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 до HH: рядок MM:

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

Фільтр шаблонів прямого напрямку для цієї проблеми. Вбудована функція int () ніколи не округляється. Для F-рядків (тобто f '') потрібен пітон 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)

Це призведе до:

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

Перевірте цю функцію - вона перетворює об'єкт timedelta в рядок "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)

Один лайнер. Оскільки timedeltas не пропонує стринг-тайм datetime, поверніть timedelta до дати та використовуйте stroll.

Це не може досягти лише запитуваного формату формату ОР Години: Хвилини, тепер ви можете використовувати повну потужність форматування строкових дат, якщо ваші вимоги зміняться на інше представлення.

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

Це також вирішує роздратування тим, що timedeltas форматується в рядки як H: MM: SS, а не HH: MM: SS, що призводить мене до цієї проблеми, і рішення, яким я поділився.

Якщо у вас вже є obed timedelta, тоді просто перетворіть цей об'єкт у рядок. Видаліть останні 3 символи рядка та роздрукуйте. Це дозволить урізати секундну частину та надрукувати решту у форматі Години: Хвилини.

t = str(timedeltaobj) 

print t[:-3]

Якщо 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

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'

Дякуємо всім за допомогу. Я взяв багато ваших ідей і зібрав їх, дайте мені знати, що ви думаєте.

До класу я додав два методи:

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

У своєму джанго я використав це (сума - це об'єкт, і це у словнику):

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