Python - 日期和时间

上一页
下一页

Python 程序可以通过多种方式处理日期和时间。在日期格式之间进行转换是计算机的一项常见任务。Python 标准库中的以下模块处理与日期和时间相关的处理：

  • DateTime 模块

  • Time 模块

  • Calendar 模块

什么是 Tick 间隔？

时间间隔是以秒为单位的浮点数。特定时间点以 1970 年 1 月 1 日凌晨 12:00（纪元）以来的秒数表示。

Python 中有一个流行的 time 模块，它提供用于处理时间以及在表示形式之间进行转换的函数。函数 time.time() 返回自 1970 年 1 月 1 日凌晨 12:00（纪元）以来的系统当前时间（以滴答数表示）。

示例

import time # This is required to include time module.
ticks = time.time()
print ("Number of ticks since 12:00am, January 1, 1970:", ticks)

这将产生如下结果：

Number of ticks since 12:00am, January 1, 1970: 1681928297.5316436

使用滴答数进行日期运算很容易。但是，在此格式中无法表示纪元之前的日期。未来遥远的日期也无法以这种方式表示——对于 UNIX 和 Windows，截止点是在 2038 年的某个时候。

什么是 TimeTuple？

Python 中的许多时间函数都将时间处理为一个包含 9 个数字的元组，如下所示：

索引 字段 值
0 4 位年份 2016
1 月份 1 到 12
2 日期 1 到 31
3 小时 0 到 23
4 分钟 0 到 59
5 秒 0 到 61（60 或 61 为闰秒）
6 星期几 0 到 6（0 为星期一）
7 一年中的第几天 1 到 366（儒略日）
8 夏令时 -1、0、1，-1 表示库确定夏令时

例如，

>>>import time
>>> print (time.localtime())

这将产生如下 输出：

time.struct_time(tm_year=2023, tm_mon=4, tm_mday=19, tm_hour=23, tm_min=49, tm_sec=8, tm_wday=2, tm_yday=109, tm_isdst=0)

上述元组等效于 struct_time 结构。此结构具有以下属性：

索引 属性 值
0 tm_year 2016
1 tm_mon 1 到 12
2 tm_mday 1 到 31
3 tm_hour 0 到 23
4 tm_min 0 到 59
5 tm_sec 0 到 61（60 或 61 为闰秒）
6 tm_wday 0 到 6（0 为星期一）
7 tm_yday 1 到 366（儒略日）
8 tm_isdst -1、0、1，-1 表示库确定夏令时

获取当前时间

要将自纪元以来的时间点（浮点数）转换为时间元组，请将浮点数传递给一个返回包含所有 9 个有效项的时间元组的函数（例如，localtime）。

import time
localtime = time.localtime(time.time())
print ("Local current time :", localtime)

这将产生以下结果，该结果可以格式化为任何其他可呈现的形式：

Local current time : time.struct_time(tm_year=2023, tm_mon=4, tm_mday=19, tm_hour=23, tm_min=42, tm_sec=41, tm_wday=2, tm_yday=109, tm_isdst=0)

获取格式化的时间

您可以根据需要格式化任何时间，但获取易读格式时间的一种简单方法是 asctime()：

import time

localtime = time.asctime( time.localtime(time.time()) )
print ("Local current time :", localtime)

这将产生以下 输出：

Local current time : Wed Apr 19 23:45:27 2023

获取一个月的日历

calendar 模块提供了广泛的方法来处理年历和月历。在这里，我们打印给定月份（2008 年 1 月）的日历。

import calendar
cal = calendar.month(2023, 4)
print ("Here is the calendar:")
print (cal)

这将产生以下 输出：

Here is the calendar:
     April 2023
Mo Tu We Th Fr Sa Su
                1  2
 3  4  5  6  7  8  9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30

Time 模块

Python 中有一个流行的 time 模块，它提供用于处理时间以及在表示形式之间进行转换的函数。以下是所有可用方法的列表。

序号 函数及描述
1 time.altzone

如果定义了本地夏令时时区，则其相对于 UTC 的偏移量（以秒为单位），如果定义了该时区。如果本地夏令时时区位于 UTC 以东（如西欧，包括英国），则为负数。仅当 daylight 非零时使用此值。
2 time.asctime([tupletime])

接受时间元组并返回一个可读的 24 个字符的字符串，例如“Tue Dec 11 18:07:14 2008”。
3 time.clock( )

以秒为单位的浮点数形式返回当前 CPU 时间。为了衡量不同方法的计算成本，time.clock 的值比 time.time 的值更有用。
4 time.ctime([secs])

类似于 asctime(localtime(secs))，并且在没有参数的情况下类似于 asctime( )
5 time.gmtime([secs])

接收自纪元以来的秒数表示的时刻，并返回一个包含 UTC 时间的 time-tuple t。注意：t.tm_isdst 始终为 0。
6 time.localtime([secs])

接收自纪元以来的秒数表示的时刻，并返回一个包含本地时间（t.tm_isdst 为 0 或 1，取决于本地规则是否将 DST 应用于时刻 secs）的 time-tuple t。
7 time.mktime(tupletime)

接收以本地时间表示的 time-tuple 表示的时刻，并返回一个浮点数，该浮点数表示自纪元以来的秒数。
8 time.sleep(secs)

挂起调用线程 secs 秒。
9 time.strftime(fmt[,tupletime])

接收以本地时间表示的 time-tuple 表示的时刻，并返回一个字符串，该字符串根据字符串 fmt 指定的格式表示该时刻。
10 time.strptime(str,fmt='%a %b %d %H:%M:%S %Y')

根据格式字符串 fmt 解析 str，并以 time-tuple 格式返回该时刻。
11 time.time( )

返回当前时刻，一个自纪元以来的秒数的浮点数。
12 time.tzset()

重置库例程使用的时区转换规则。环境变量 TZ 指定如何执行此操作。

让我们简要介绍一下这些函数。

time 模块有两个重要的可用属性。它们是：

序号 带描述的属性
1

time.timezone

属性 time.timezone 是本地时区（不含夏令时）相对于 UTC 的偏移量（在美洲 >0；在欧洲、亚洲、非洲的大部分地区 <=0）。
2

time.tzname

属性 time.tzname 是一对依赖于区域设置的字符串，分别是本地时区分别不含和含夏令时的名称。

calendar 模块

calendar 模块提供与日历相关的函数，包括打印给定月份或年份的文本日历的函数。

默认情况下，calendar 将星期一作为一周的第一天，星期日作为最后一天。要更改此设置，请调用 **calendar.setfirstweekday()** 函数。

以下是 **calendar** 模块提供的函数列表：

序号 函数及描述
1

calendar.calendar(year,w=2,l=1,c=6)

返回一个多行字符串，其中包含 year 年份的日历，格式化为三列，列之间用 c 个空格分隔。w 是每个日期的字符宽度；每行的长度为 21*w+18+2*c。l 是每个星期的行数。
2

calendar.firstweekday( )

返回每个星期开始的星期几的当前设置。默认情况下，当首次导入 calendar 时，此值为 0，表示星期一。
3

calendar.isleap(year)

如果 year 是闰年，则返回 True；否则返回 False。
4

calendar.leapdays(y1,y2)

返回 range(y1,y2) 中年份内的闰年总数。
5

calendar.month(year,month,w=2,l=1)

返回一个多行字符串，其中包含 year 年份 month 月份的日历，每行一个星期，加上两行标题。w 是每个日期的字符宽度；每行的长度为 7*w+6。l 是每个星期的行数。
6

calendar.monthcalendar(year,month)

返回一个整数列表的列表。每个子列表表示一个星期。year 年份 month 月份之外的天数设置为 0；月份内的天数设置为其月份中的日期，从 1 开始。
7

calendar.monthrange(year,month)

返回两个整数。第一个是 year 年份 month 月份的第一天的星期几代码；第二个是该月份的天数。星期几代码为 0（星期一）到 6（星期日）；月份数字为 1 到 12。
8

calendar.prcal(year,w=2,l=1,c=6)

类似于 print calendar.calendar(year,w,l,c)。
9

calendar.prmonth(year,month,w=2,l=1)

类似于 print calendar.month(year,month,w,l)。
10

calendar.setfirstweekday(weekday)

将每个星期的第一天设置为星期几代码 weekday。星期几代码为 0（星期一）到 6（星期日）。
11

calendar.timegm(tupletime)

time.gmtime 的反函数：接收 time-tuple 形式的时刻，并返回自纪元以来的秒数的浮点数，表示同一时刻。
12

calendar.weekday(year,month,day)

返回给定日期的星期几代码。星期几代码为 0（星期一）到 6（星期日）；月份数字为 1（一月）到 12（十二月）。

Python datetime 模块

Python 的 datetime 模块包含在标准库中。它包含有助于操作数据和时间数据并执行日期时间算术的类。

datetime 类的对象要么是已知的，要么是朴素的。如果对象包含时区信息，则它是已知的，否则它被归类为朴素的。date 类对象是朴素的，而 time 和 datetime 对象是已知的。

Python date 对象

date 对象表示一个日期，包括年份、月份和日期。当前的格里高利历法在两个方向上无限期地扩展。

语法

datetime.date(year, month, day)

参数必须是整数，在以下范围内：

  • **year** − MINYEAR <= year <= MAXYEAR

  • **month** − 1 <= month <= 12

  • **day** − 1 <= day <= 给定月份和年份中的天数

如果任何参数的值超出这些范围，则会引发 ValueError。

示例

from datetime import date
date1 = date(2023, 4, 19)
print("Date:", date1)
date2 = date(2023, 4, 31)

它将产生以下 **输出**：

Date: 2023-04-19
Traceback (most recent call last):
 File "C:\Python311\hello.py", line 8, in <module>
  date2 = date(2023, 4, 31)
ValueError: day is out of range for month

date 类属性

  • **date.min** − 可表示的最早日期，date(MINYEAR, 1, 1)。

  • **date.max** − 可表示的最新日期，date(MAXYEAR, 12, 31)。

  • **date.resolution** − 非相等 date 对象之间可能的最小差异。

  • **date.year** − 包含在 MINYEAR 和 MAXYEAR 之间。

  • **date.month** − 包含在 1 和 12 之间。

  • **date.day** − 包含在 1 和给定年份的给定月份的天数之间。

示例

from datetime import date

# Getting min date
mindate = date.min
print("Minimum Date:", mindate)

# Getting max date
maxdate = date.max
print("Maximum Date:", maxdate)

Date1 = date(2023, 4, 20)
print("Year:", Date1.year)
print("Month:", Date1.month)
print("Day:", Date1.day)

它将产生以下 **输出**：

Minimum Date: 0001-01-01
Maximum Date: 9999-12-31
Year: 2023
Month: 4
Day: 20

Date 类中的类方法

  • **today()** − 返回当前本地日期。

  • **fromtimestamp(timestamp)** − 返回对应于 POSIX 时间戳的本地日期，例如 time.time() 返回的日期。

  • **fromordinal(ordinal)** − 返回对应于前格里高利序数的日期，其中年份 1 的 1 月 1 日的序数为 1。

  • **fromisoformat(date_string)** − 返回对应于以任何有效的 ISO 8601 格式给定的 date_string 的日期，除了序数日期

示例

from datetime import date

print (date.today())
d1=date.fromisoformat('2023-04-20')
print (d1)
d2=date.fromisoformat('20230420')
print (d2)
d3=date.fromisoformat('2023-W16-4')
print (d3)

它将产生以下 **输出**：

2023-04-20
2023-04-20
2023-04-20
2023-04-20

Date 类中的实例方法

  • **replace()** − 通过关键字参数指定的新值替换指定的属性，返回一个日期。

  • **timetuple()** − 返回一个 time.struct_time，例如 time.localtime() 返回的。

  • **toordinal()** − 返回日期的前格里高利序数，其中年份 1 的 1 月 1 日的序数为 1。对于任何日期对象 d，date.fromordinal(d.toordinal()) == d。

  • **weekday()** − 将一周中的某一天作为整数返回，其中星期一为 0，星期日为 6。

  • **isoweekday()** − 将一周中的某一天作为整数返回，其中星期一为 1，星期日为 7。

  • **isocalendar()** − 返回一个命名元组对象，包含三个组件：年份、星期和星期几。

  • **isoformat()** − 返回一个字符串，表示以 ISO 8601 格式 YYYY-MM-DD 表示的日期

  • **__str__()** − 对于日期 d，str(d) 等效于 d.isoformat()

  • **ctime()** − 返回一个表示日期的字符串

  • **strftime(format)** − 返回一个表示日期的字符串，由显式格式字符串控制。

  • **__format__(format)** − 与 date.strftime() 相同。

示例

from datetime import date
d = date.fromordinal(738630) # 738630th day after 1. 1. 0001
print (d)
print (d.timetuple())
# Methods related to formatting string output
print (d.isoformat())
print (d.strftime("%d/%m/%y"))
print (d.strftime("%A %d. %B %Y"))
print (d.ctime())

print ('The {1} is {0:%d}, the {2} is {0:%B}.'.format(d, "day", "month"))

# Methods for to extracting 'components' under different calendars
t = d.timetuple()
for i in t:
   print(i)
   
ic = d.isocalendar()
for i in ic:
   print(i)
   
# A date object is immutable; all operations produce a new object
print (d.replace(month=5))

它将产生以下 **输出**：

2023-04-20
time.struct_time(tm_year=2023, tm_mon=4, tm_mday=20, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=110, tm_isdst=-1)
2023-04-20
20/04/23
Thursday 20. April 2023
Thu Apr 20 00:00:00 2023
The day is 20, the month is April.
2023
4
20
0
0
0
3
110
-1
2023
16
4
2023-05-20

Python time 模块

time 类对象表示一天中的本地时间。它独立于任何特定的一天。如果对象包含 tzinfo 详细信息，则它是已知对象。如果为 None，则 time 对象是朴素对象。

语法

datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None)

所有参数都是可选的。tzinfo 可以是 None，也可以是 tzinfo 子类的实例。其余参数必须是以下范围内的整数：

  • **hour** − 0 <= hour < 24，

  • **minute** − 0 <= minute < 60，

  • **second** − 0 <= second < 60，

  • **microsecond** − 0 <= microsecond < 1000000

如果任何参数的值超出这些范围，则会引发 ValueError。

示例

from datetime import time

time1 = time(8, 14, 36)
print("Time:", time1)

time2 = time(minute = 12)
print("time", time2)

time3 = time()
print("time", time3)

time4 = time(hour = 26)

它将产生以下 **输出**：

Time: 08:14:36
time 00:12:00
time 00:00:00
Traceback (most recent call last):
  File "/home/cg/root/64b912f27faef/main.py", line 12, in 
    time4 = time(hour = 26)
ValueError: hour must be in 0..23

类属性

  • **time.min** − 可表示的最早时间，time(0, 0, 0, 0)。

  • **time.max** − 可表示的最新时间，time(23, 59, 59, 999999)。

  • **time.resolution** − 非相等 time 对象之间可能的最小差异。

示例

from datetime import time
print(time.min)
print(time.max)
print (time.resolution)

它将产生以下 **输出**：

00:00:00
23:59:59.999999
0:00:00.000001

实例属性

  • **time.hour** − 在 range(24) 中

  • **time.minute** − 在 range(60) 中

  • **time.second** − 在 range(60) 中

  • **time.microsecond** − 在 range(1000000) 中

  • **time.tzinfo** − 传递给 time 构造函数的 tzinfo 参数，或 None。

示例

from datetime import time
t = time(8,23,45,5000)
print(t.hour)
print(t.minute)
print (t.second)
print (t.microsecond)

它将产生以下 **输出**：

8
23
455000

time 对象的实例方法

  • **replace()** − 返回具有相同值的时间，但由任何指定的关键字参数赋予新值的属性除外。

  • **isoformat()** − 返回一个字符串，表示以 ISO 8601 格式表示的时间

  • **__str__()** − 对于时间 t，str(t) 等效于 t.isoformat()。

  • **strftime(format)** − 返回一个字符串，表示由显式格式字符串控制的时间。

  • **__format__(format)** − 与 time.strftime() 相同。

  • **utcoffset()** − 如果 tzinfo 为 None，则返回 None，否则返回 self.tzinfo.utcoffset(None)，

  • **dst()** − 如果 tzinfo 为 None，则返回 None，否则返回 self.tzinfo.dst(None)，

  • **tzname()** − 如果 tzinfo 为 None，则返回 None，否则返回 self.tzinfo.tzname(None)，或引发异常

Python datetime 对象

datetime 类对象包含日期和时间的信息。它假设当前的格里高利历法在两个方向上无限期地扩展；就像 time 对象一样，并且每一天正好有 3600*24 秒。

语法

datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)

年份、月份和日期参数是必需的。

  • **year** − MINYEAR <= year <= MAXYEAR，

  • **month** − 1 <= month <= 12，

  • **day** − 1 <= day <= 给定月份和年份中的天数，

  • **hour** − 0 <= hour < 24，

  • **minute** − 0 <= minute < 60，

  • **second** −0 <= second < 60，

  • **microsecond** − 0 <= microsecond < 1000000，

  • **fold** − 在 [0, 1] 中。

如果任何参数的值超出范围，则会引发 ValueError。

示例

from datetime import datetime
dt = datetime(2023, 4, 20)
print(dt)

dt = datetime(2023, 4, 20, 11, 6, 32, 5000)
print(dt)

它将产生以下 **输出**：

2023-04-20 00:00:00
2023-04-20 11:06:32.005000

类属性

  • **datetime.min** − 可表示的最早 datetime，datetime(MINYEAR, 1, 1, tzinfo=None)。

  • **datetime.max** − 可表示的最新 datetime，datetime(MAXYEAR, 12, 31, 23, 59, 59, 999999, tzinfo=None)。

  • **datetime.resolution** − 非相等 datetime 对象之间可能的最小差异，timedelta(microseconds=1)。

示例

from datetime import datetime
min = datetime.min
print("Min DateTime ", min)

max = datetime.max
print("Max DateTime ", max)

它将产生以下 **输出**：

Min DateTime 0001-01-01 00:00:00
Max DateTime 9999-12-31 23:59:59.999999

datetime 对象的实例属性

  • **datetime.year** − 包含在 MINYEAR 和 MAXYEAR 之间。

  • **datetime.month** − 包含在 1 和 12 之间。

  • **datetime.day** − 包含在 1 和给定年份的给定月份的天数之间。

  • **datetime.hour** − 在 range(24) 中

  • **datetime.minute** − 在 range(60) 中

  • **datetime.second** − 在 range(60) 中

  • **datetime.microsecond** − 在 range(1000000) 中。

  • **datetime.tzinfo** − 传递给 datetime 构造函数的 tzinfo 对象，或者如果未传递则为 None。

  • **datetime.fold** − 在 [0, 1] 中。用于在重复间隔期间消除墙时间的歧义。

示例

from datetime import datetime
dt = datetime.now()

print("Day: ", dt.day)
print("Month: ", dt.month)
print("Year: ", dt.year)
print("Hour: ", dt.hour)
print("Minute: ", dt.minute)
print("Second: ", dt.second)

它将产生以下 **输出**：

Day: 20
Month: 4
Year: 2023
Hour: 15
Minute: 5
Second: 52

datetime 对象的类方法

  • **today()** − 返回当前本地 datetime，tzinfo 为 None。

  • **now(tz=None)** − 返回当前本地日期和时间。

  • **utcnow()** − 返回当前 UTC 日期和时间，tzinfo 为 None。

  • **utcfromtimestamp(timestamp)** − 返回对应于 POSIX 时间戳的 UTC datetime，tzinfo 为 None

  • fromtimestamp(timestamp, timezone.utc) − 在 POSIX 兼容平台上，它等价于 datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(seconds=timestamp)

  • fromordinal(ordinal) − 返回对应于前儒略历序数的 datetime 对象，其中公元 1 年 1 月 1 日的序数为 1。

  • fromisoformat(date_string) − 返回对应于任何有效 ISO 8601 格式的 date_string 的 datetime 对象。

datetime 对象的实例方法

  • date() − 返回具有相同年、月和日的 date 对象。

  • time() − 返回具有相同小时、分钟、秒、微秒和 fold 属性的 time 对象。

  • timetz() − 返回具有相同小时、分钟、秒、微秒、fold 和 tzinfo 属性的 time 对象。另请参见方法 time()。

  • replace() − 返回一个具有相同属性的 datetime 对象，除了通过指定的关键字参数赋予新值的那些属性。

  • astimezone(tz=None) − 返回一个具有新的 tzinfo 属性 tz 的 datetime 对象

  • utcoffset() − 如果 tzinfo 为 None，则返回 None，否则返回 self.tzinfo.utcoffset(self)

  • dst() − 如果 tzinfo 为 None，则返回 None，否则返回 self.tzinfo.dst(self)

  • tzname() − 如果 tzinfo 为 None，则返回 None，否则返回 self.tzinfo.tzname(self)

  • **timetuple()** − 返回一个 time.struct_time，例如 time.localtime() 返回的。

  • datetime.toordinal() − 返回日期的前儒略历序数。

  • timestamp() − 返回对应于 datetime 实例的 POSIX 时间戳。

  • isoweekday() − 返回一周中的某一天作为整数，其中星期一为 1，星期日为 7。

  • isocalendar() − 返回一个包含三个组件的命名元组：年、周和星期几。

  • isoformat(sep='T', timespec='auto') − 返回一个以 ISO 8601 格式表示日期和时间的字符串

  • __str__() − 对于 datetime 实例 d，str(d) 等价于 d.isoformat(' ')。

  • ctime() − 返回一个表示日期和时间的字符串

  • strftime(format) − 返回一个表示日期和时间的字符串，由一个显式格式字符串控制。

  • __format__(format) − 与 strftime() 相同。

示例

from datetime import datetime, date, time, timezone

# Using datetime.combine()
d = date(2022, 4, 20)
t = time(12, 30)
datetime.combine(d, t)

# Using datetime.now()
d = datetime.now()
print (d)

# Using datetime.strptime()
dt = datetime.strptime("23/04/20 16:30", "%d/%m/%y %H:%M")

# Using datetime.timetuple() to get tuple of all attributes
tt = dt.timetuple()
for it in tt:
   print(it)

# Date in ISO format
ic = dt.isocalendar()
for it in ic:
   print(it)

它将产生以下 **输出**：

2023-04-20 15:12:49.816343
2020
4
23
16
30
0
3
114
-1
2020
17
4

Python timedelta 对象

timedelta 对象表示两个日期或两个时间对象之间的持续时间。

语法

datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

在内部，属性存储在天、秒和微秒中。其他参数将转换为这些单位 −

  • 毫秒转换为 1000 微秒。

  • 分钟转换为 60 秒。

  • 小时转换为 3600 秒。

  • 周转换为 7 天。

然后对天、秒和微秒进行标准化，以便表示唯一。

示例

以下示例显示 Python 在内部仅存储天、秒和微秒。

from datetime import timedelta
delta = timedelta(
   days=100,
   seconds=27,
   microseconds=10,
   milliseconds=29000,
   minutes=5,
   hours=12,
   weeks=2
)
# Only days, seconds, and microseconds remain
print (delta)

它将产生以下 **输出**：

114 days, 12:05:56.000010

示例

以下示例显示如何将 timedelta 对象添加到 datetime 对象。

from datetime import datetime, timedelta

date1 = datetime.now()

date2= date1+timedelta(days = 4)
print("Date after 4 days:", date2)

date3 = date1-timedelta(15)
print("Date before 15 days:", date3)

它将产生以下 **输出**：

Date after 4 days: 2023-04-24 18:05:39.509905
Date before 15 days: 2023-04-05 18:05:39.509905

timedelta 对象的类属性

  • timedelta.min − 最小的 timedelta 对象，timedelta(-999999999)。

  • timedelta.max − 最大的 timedelta 对象，timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)。

  • timedelta.resolution − 不相等 timedelta 对象之间可能的最小差异，timedelta(microseconds=1)

示例

from datetime import timedelta

# Getting minimum value
min = timedelta.min
print("Minimum value:", min)

max = timedelta.max
print("Maximum value", max)

它将产生以下 **输出**：

Minimum value: -999999999 days, 0:00:00
Maximum value 999999999 days, 23:59:59.999999

timedelta 对象的实例属性

由于内部只存储天、秒和微秒，因此这些是 timedelta 对象的唯一实例属性。

  • days − 在 -999999999 到 999999999（含）之间

  • seconds − 在 0 到 86399（含）之间

  • microseconds − 在 0 到 999999（含）之间

timedelta 对象的实例方法

timedelta.total_seconds() − 返回持续时间中包含的秒数总和。

示例

from datetime import timedelta
year = timedelta(days=365)
years = 5 * year
print (years)
print (years.days // 365)
646
year_1 = years // 5
print(year_1.days)

它将产生以下 **输出**：

1825 days, 0:00:00
5
365
打印页面
上一页
下一页
广告