将timedelta格式化为字符串

>>> 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部分把它重新组合在一起。

按照上面Joe的示例值，我将使用模算术运算符，因此:

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

注意，Python中的整数除法默认是四舍五入;如果想要更显式，可以适当使用math.floor()或math.ceil()。

您可以使用str()将timedelta转换为字符串。这里有一个例子:

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

谢谢大家的帮助。我把你的很多想法放在一起，让我知道你的想法。

我像这样在类中添加了两个方法:

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中，我使用了这个(sum是对象，它在一个字典中):

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

如你所知，你可以通过访问.seconds属性从timedelta对象中获得total_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

我的datetime.timedelta对象超过了一天。这是一个更深层次的问题。以上所有讨论都假设时间不超过一天。timedelta实际上是一个由日、秒和微秒组成的元组。上面的讨论应该像joe一样使用td.seconds，但如果你有days，它不会包含在seconds值中。

我得到2个日期时间和打印天和小时之间的时间跨度。

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

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)

提问者想要一个比典型的更好的格式:

  >>> 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天，h:m:s”。但是，秒可能有分数，打印输出中没有前导0，所以列很乱。

如果你喜欢，下面是我的日常工作:

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'

他已经有一个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)

无论时间增量是天还是年，这都是有效的。

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

我知道这是一个老问题，但我使用datetime.utcfromtimestamp()来解决这个问题。它取秒数并返回一个datetime，该datetime可以像任何其他datetime一样格式化。

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

只要你停留在时间部分的合法范围内，这就应该工作，即它不会返回1234:35，因为小时是<= 23。

在这里，我会认真考虑奥卡姆剃刀方法:

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年了，我爱上了这门语言!

请检查这个函数-它将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)

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'

我个人使用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支持人类可读的更大的值，并且也很好地本地化了。

显然，它的灵感来自Django的contrib.humanize模块，所以既然你正在使用Django，你可能应该使用它。

下面是一个通用函数，用于将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

如果你已经有一个timedelta obj，那么只需将obj转换为字符串。删除字符串的最后3个字符并打印。这将截断秒部分，并以小时:分钟的格式打印其余部分。

t = str(timedeltaobj)


print t[:-3]

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

我使用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/

针对这个问题的一个直接的模板过滤器。内置函数int()从不四舍五入。f - string(即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

一个班轮。由于timedelta不提供datetime的strftime，所以将timedelta带回datetime，并使用stftime。

这不仅可以实现OP要求的格式Hours:Minutes，现在您可以利用datetime的strftime的全部格式化功能，如果您的需求更改为另一种表示形式。

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的字符串的烦恼，这导致了我的这个问题，以及我分享的解决方案。

如果你碰巧在你的包中有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

下面是一个stringify timedelta.total_seconds()的函数。它在python2和python3中工作。

def strf_interval(seconds):
days, remainder = divmod(seconds, 86400)
hours, remainder = divmod(remainder, 3600)
minutes, seconds = divmod(remainder, 60)
return '{} {} {} {}'.format(
"" if int(days) == 0 else str(int(days)) + ' days',
"" if int(hours) == 0 else str(int(hours)) + ' hours',
"" if int(minutes) == 0 else str(int(minutes))  + ' mins',
"" if int(seconds) == 0 else str(int(seconds))  + ' secs'
)

示例输出:

>>> print(strf_interval(1))
1 secs
>>> print(strf_interval(100))
1 mins 40 secs
>>> print(strf_interval(1000))
16 mins 40 secs
>>> print(strf_interval(10000))
2 hours 46 mins 40 secs
>>> print(strf_interval(100000))
1 days 3 hours 46 mins 40 secs

我有一个函数:

def period(delta, pattern):
d = {'d': delta.days}
d['h'], rem = divmod(delta.seconds, 3600)
d['m'], d['s'] = divmod(rem, 60)
return pattern.format(**d)

例子:

>>> td = timedelta(seconds=123456789)
>>> period(td, "{d} days {h}:{m}:{s}")
'1428 days 21:33:9'
>>> period(td, "{h} hours, {m} minutes and {s} seconds, {d} days")
'21 hours, 33 minutes and 9 seconds, 1428 days'

我继续从MarredCheese的回答添加了year， month， millicesond和microsecond

除了second之外，所有的数字都被格式化为整数，因此秒的分数可定制。

@kfmfe04要求几分之一秒，所以我发布了这个解决方案

在main中有一些例子。

from string import Formatter
from datetime import timedelta


def strfdelta(tdelta, fmt='{D:02}d {H:02}h {M:02}m {S:02.0f}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.0f}s' --> '05d 08h 04m 02s' (default)
'{W}w {D}d {H}:{M:02}:{S:02.0f}'     --> '4w 5d 8:04:02'
'{D:2}d {H:2}:{M:02}:{S:02.0f}'      --> ' 5d  8:04:02'
'{H}h {S:.0f}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 = tdelta.total_seconds()
elif inputtype in ['s', 'seconds']:
remainder = float(tdelta)
elif inputtype in ['m', 'minutes']:
remainder = float(tdelta)*60
elif inputtype in ['h', 'hours']:
remainder = float(tdelta)*3600
elif inputtype in ['d', 'days']:
remainder = float(tdelta)*86400
elif inputtype in ['w', 'weeks']:
remainder = float(tdelta)*604800


f = Formatter()
desired_fields = [field_tuple[1] for field_tuple in f.parse(fmt)]
possible_fields = ('Y','m','W', 'D', 'H', 'M', 'S', 'mS', 'µS')
constants = {'Y':86400*365.24,'m': 86400*30.44 ,'W': 604800, 'D': 86400, 'H': 3600, 'M': 60, 'S': 1, 'mS': 1/pow(10,3) , 'µS':1/pow(10,6)}
values = {}
for field in possible_fields:
if field in desired_fields and field in constants:
Quotient, remainder = divmod(remainder, constants[field])
values[field] = int(Quotient) if field != 'S' else Quotient + remainder
return f.format(fmt, **values)


if __name__ == "__main__":
td = timedelta(days=717, hours=3, minutes=5, seconds=8, microseconds=3549)
print(strfdelta(td,'{Y} years {m} months {W} weeks {D} days {H:02}:{M:02}:{S:02}'))
print(strfdelta(td,'{m} months {W} weeks {D} days {H:02}:{M:02}:{S:02.4f}'))
td = timedelta( seconds=8, microseconds=8549)
print(strfdelta(td,'{S} seconds {mS} milliseconds {µS} microseconds'))
print(strfdelta(td,'{S:.0f} seconds {mS} milliseconds {µS} microseconds'))
print(strfdelta(pow(10,7),inputtype='s'))

输出:

1 years 11 months 2 weeks 3 days 01:09:56.00354900211096
23 months 2 weeks 3 days 00:12:20.0035
8.008549 seconds 8 milliseconds 549 microseconds
8 seconds 8 milliseconds 549 microseconds
115d 17h 46m 40s

Timedelta到字符串，用于打印运行时间信息。

def strfdelta_round(tdelta, round_period='second'):
"""timedelta to string,  use for measure running time
attend period from days downto smaller period, round to minimum period
omit zero value period
"""
period_names = ('day', 'hour', 'minute', 'second', 'millisecond')
if round_period not in period_names:
raise Exception(f'round_period "{round_period}" invalid, should be one of {",".join(period_names)}')
period_seconds = (86400, 3600, 60, 1, 1/pow(10,3))
period_desc = ('days', 'hours', 'mins', 'secs', 'msecs')
round_i = period_names.index(round_period)
  

s = ''
remainder = tdelta.total_seconds()
for i in range(len(period_names)):
q, remainder = divmod(remainder, period_seconds[i])
if int(q)>0:
if not len(s)==0:
s += ' '
s += f'{q:.0f} {period_desc[i]}'
if i==round_i:
break
if i==round_i+1:
s += f'{remainder} {period_desc[round_i]}'
break
    

return s

例如，自动省略零前导周期:

>>> td = timedelta(days=0, hours=2, minutes=5, seconds=8, microseconds=3549)
>>> strfdelta_round(td, 'second')
'2 hours 5 mins 8 secs'

或者省略中间的零周期:

>>> td = timedelta(days=2, hours=0, minutes=5, seconds=8, microseconds=3549)
>>> strfdelta_round(td, 'millisecond')
'2 days 5 mins 8 secs 3 msecs'

或舍入至分钟，省略以下分钟:

>>> td = timedelta(days=1, hours=2, minutes=5, seconds=8, microseconds=3549)
>>> strfdelta_round(td, 'minute')
'1 days 2 hours 5 mins'

可能:

>>> import datetime
>>> dt0 = datetime.datetime(1,1,1)
>>> td = datetime.timedelta(minutes=34, hours=12, seconds=56)
>>> (dt0+td).strftime('%X')
'12:34:56'
>>> (dt0+td).strftime('%M:%S')
'34:56'
>>> (dt0+td).strftime('%H:%M')
'12:34'
>>>

我建议使用以下方法，这样我们就可以利用标准格式化函数pandas.Timestamp.strftime!

from pandas import Timestamp, Timedelta


(Timedelta("2 hours 30 min") + Timestamp("00:00:00")).strftime("%H:%M")

我想这样做，所以写了一个简单的函数。它对我来说非常有用，而且非常通用(支持年到微秒，以及任何粒度级别，例如，你可以选择“2天4小时48分钟”和“2天4小时”和“2天4.8小时”等。

def pretty_print_timedelta(t, max_components=None, max_decimal_places=2):
'''
Print a pretty string for a timedelta.
For example datetime.timedelta(days=2, seconds=17280) will be printed as '2 days, 4 hours, 48 minutes'. Setting max_components to e.g. 1 will change this to '2.2 days', where the
number of decimal points can also be set.
'''
time_scales = [timedelta(days=365), timedelta(days=1), timedelta(hours=1), timedelta(minutes=1), timedelta(seconds=1), timedelta(microseconds=1000), timedelta(microseconds=1)]
time_scale_names_dict = {timedelta(days=365): 'year',
timedelta(days=1): 'day',
timedelta(hours=1): 'hour',
timedelta(minutes=1): 'minute',
timedelta(seconds=1): 'second',
timedelta(microseconds=1000): 'millisecond',
timedelta(microseconds=1): 'microsecond'}
count = 0
txt = ''
first = True
for scale in time_scales:
if t >= scale:
count += 1
if count == max_components:
n = t / scale
else:
n = int(t / scale)
            

t -= n*scale
        

n_txt = str(round(n, max_decimal_places))
if n_txt[-2:]=='.0': n_txt = n_txt[:-2]
txt += '{}{} {}{}'.format('' if first else ', ', n_txt, time_scale_names_dict[scale], 's' if n>1 else '', )
if first:
first = False
        

        

if len(txt) == 0:
txt = 'none'
return txt

# Format seconds to days, hours, minutes and seconds string
def ptime(seconds):
if(seconds >= 86400):
d = seconds // 86400 # // floor division
return (f"{round(d)}d") + ptime(seconds - d * 86400)
else:
if(seconds >= 3600):
h = seconds // 3600
return (f"{round(h)}h") + ptime(seconds - h * 3600)
else:
if(seconds >= 60):
m = seconds // 60
return(f"{round(m)}m" + ptime(seconds - m * 60))
else:
if (seconds > 0):
return(f"{round(seconds)}s")
else:
return("")

我有同样的问题，我使用熊猫Timedeltas，不想带来额外的依赖关系(另一个答案提到humanfriendly)，所以我写了这个小函数只打印出相关信息:

def format_timedelta(td: pd.Timedelta) -> str:
if pd.isnull(td):
return str(td)
else:
c = td.components._asdict()
return ", ".join(f"{n} {unit}" for unit, n in c.items() if n)

例如，pd.Timedelta(hours=3, seconds=12)将打印为3 hours, 12 seconds。