Python - 日期和时间

Python 程序可以通过多种方式处理日期和时间。对于计算机来说，日期格式之间的转换是一项常见的工作。Python 标准库中的以下模块处理日期和时间相关的处理 -

日期时间模块
时间模块
日历模块

什么是刻度间隔

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

Python 中有一个流行的时间模块，它提供了处理时间以及在表示形式之间进行转换的函数。函数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 年的某个时间。

什么是时间元组？

许多 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 表示图书馆确定 DST

例如，

>>>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_小时	0 至 23
4	最小时间	0 至 59
5	tm_秒	0 到 61（60 或 61 是闰秒）
6	tm_wday	0 到 6（0 是星期一）
7	tm_yday	1 到 366（儒略日）
8	tm_isdst	-1, 0, 1, -1 表示图书馆确定 DST

获取当前时间

要将自纪元浮点值起的秒数的时刻转换为时间元组，请将浮点值传递给返回包含所有有效九项的时间元组的函数（例如，本地时间）。

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

获取一个月的日历

日历模块提供了多种使用年历和月历的方法。在这里，我们打印给定月份（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

时间模块

Python 中有一个流行的时间模块，它提供了处理时间和在表示之间进行转换的函数。这是所有可用方法的列表。

先生。	功能及描述
1	时间.altzone 本地 DST 时区的偏移量，以 UTC 以西的秒数为单位（如果已定义）。如果当地 DST 时区位于 UTC 以东（如西欧，包括英国），则此值为负。仅当日光非零时才使用此选项。
2	time.asctime([tupletime]) 接受时间元组并返回可读的 24 个字符的字符串，例如“Tue Dec 11 18:07:14 2008”。
3	时间.时钟( ) 以浮点秒数形式返回当前 CPU 时间。为了衡量不同方法的计算成本，time.clock 的值比 time.time() 的值更有用。
4	time.ctime([秒]) 就像 asctime(localtime(secs)) 一样，不带参数就像 asctime( )
5	time.gmtime([秒]) 接受自纪元以来以秒为单位表示的时刻，并返回带有 UTC 时间的时间元组 t。注意：t.tm_isdst 始终为 0
6	time.localtime([秒]) 接受自纪元以来以秒为单位表示的时刻，并返回包含本地时间的时间元组 t（t.tm_isdst 为 0 或 1，具体取决于 DST 是否按本地规则应用于即时秒）。
7	time.mktime(元组时间) 接受以本地时间的时间元组表示的时刻，并返回一个浮点值，该时刻以自纪元以来的秒数表示。
8	睡眠时间（秒）将调用线程挂起 secs 秒。
9	time.strftime(fmt[,元组时间]) 接受表示为本地时间时间元组的时刻，并返回表示由字符串 fmt 指定的时刻的字符串。
10	time.strptime(str,fmt='%a %b %d %H:%M:%S %Y') 根据格式字符串 fmt 解析 str 并以时间元组格式返回时刻。
11	时间.时间( ) 返回当前时刻，即自纪元以来的浮点数秒数。
12	时间.tzset() 重置库例程使用的时间转换规则。环境变量 TZ 指定这是如何完成的。

让我们简要介绍一下这些功能。

时间模块有两个重要的属性。他们是 -

先生。	带有描述的属性
1	时间.时区属性 time.timezone 是本地时区（不含夏令时）相对于 UTC 的秒数偏移量（在美洲>0；在欧洲、亚洲、非洲大部分地区<=0）。
2	时间.tzname 属性 time.tzname 是一对与语言环境相关的字符串，它们分别是不带 DST 和带 DST 的本地时区的名称。

先生。

带有描述的属性

时间.时区

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

时间.tzname

属性 time.tzname 是一对与语言环境相关的字符串，它们分别是不带 DST 和带 DST 的本地时区的名称。

日历模块

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

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

以下是日历模块可用的功能列表-

先生。	功能及描述
1	日历.日历(年,w=2,l=1,c=6) 返回一个多行字符串，其中包含年的日历，格式为三列，以 c 空格分隔。w 是每个日期的字符宽度；每条线的长度为 21w+18+2c。l 是每周的行数。
2	日历.firstweekday( ) 返回每周开始的工作日的当前设置。默认情况下，首次导入日历时，此值为 0，表示星期一。
3	日历.isleap(年) 如果年份是闰年，则返回 True；否则为假。
4	日历.闰日(y1,y2) 返回范围 (y1,y2) 内年份的闰日总数。
5	日历.月份(年,月,w=2,l=1) 返回一个多行字符串，其中包含一年中月份的日历，每周一行加上两个标题行。w 是每个日期的字符宽度；每条线的长度为 7*w+6。l 是每周的行数。
6	calendar.monthcalendar(年,月) 返回整数列表的列表。每个子列表表示一周。年中月份以外的天数设置为 0；该月内的天数设置为其所在月份的日期、1 及以上。
7	日历.月份范围（年，月）返回两个整数。第一个是当年某月第一天的工作日代码；第二个是该月的天数。工作日代码为 0（星期一）至 6（星期日）；月份数字为 1 到 12。
8	日历.prcal(年,w=2,l=1,c=6) 就像打印 calendar.calendar(year,w,l,c) 一样。
9	日历.prmonth(年,月,w=2,l=1) 就像打印 calendar.month(year,month,w,l) 一样。
10	日历.setfirstweekday(工作日) 将每周的第一天设置为工作日代码 weekday。工作日代码为 0（星期一）至 6（星期日）。
11	日历.timegm(元组时间) time.gmtime 的倒数：接受时间元组形式的时间瞬间，并返回自纪元以来的浮点数秒数。
12	日历.工作日（年，月，日）返回给定日期的工作日代码。工作日代码为 0（星期一）至 6（星期日）；月份编号为 1（一月）至 12（十二月）。

日期时间模块

Python 的 datetime 模块包含在标准库中。它由帮助操作数据和时间数据以及执行日期时间算术的类组成。

日期时间类的对象要么是感知的，要么是天真的。如果对象包含时区信息，则它是已知的，如果不包含，则它被归类为幼稚的。日期类的对象是幼稚的，而时间和日期时间对象是感知的。

日期

日期对象表示具有年、月和日的日期。当前的公历在两个方向上无限期地延长。

句法

datetime.date(year, month, day)

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

年− MINYEAR <= 年 <= MAXYEAR
月− 1 <= 月 <= 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.min - 最早可表示的日期，date(MINYEAR, 1, 1)。
date.max - 最新的可表示日期，date(MAXYEAR, 12, 31)。
date.resolution - 不相等的日期对象之间的最小可能差异。
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

日期类中的类方法

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)

它将产生以下输出-

日期类中的实例方法

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

时间

对象时间类表示当天的当地时间。它独立于任何特定的一天。如果该对象包含 tzinfo 详细信息，则它是感知对象。如果它是 None 那么时间对象就是朴素对象。

句法

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

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

小时− 0 <= 小时 < 24，
分钟− 0 <= 分钟 < 60，
第二个− 0 <= 第二个 < 60，
微秒− 0 <= 微秒 < 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 - 非等时间对象之间的最小可能差异。

例子

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 - 在范围内(24)
时间.分钟- 在范围内(60)
time.second - 在范围内(60)
time.microsecond - 在范围内（1000000）
time.tzinfo - 时间构造函数的 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

实例方法

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)，或引发异常

约会时间

datetime类的对象包含日期和时间的信息。它假设当前的公历在两个方向上延伸；就像一个时间对象，每天正好有3600*24秒。

句法

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

需要年、月和日参数。

年− MINYEAR <= 年 <= MAXYEAR，
月− 1 <= 月 <= 12，
day − 1 <= day <= 给定月份和年份的天数，
小时− 0 <= 小时 < 24，
分钟− 0 <= 分钟 < 60，
第二个−0 <= 第二个 < 60，
微秒− 0 <= 微秒 < 1000000，
折叠- 在 [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(MINYEAR, 1, 1, tzinfo=None)。
datetime.max - 最新可表示的日期时间，datetime(MAXYEAR, 12, 31, 23, 59, 59, 999999, tzinfo=None)。
datetime.resolution - 不相等的日期时间对象之间的最小可能差异，timedelta（微秒= 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.year - 在 MINYEAR 和 MAXYEAR 之间（包括在内）。
datetime.month - 1 到 12 之间（含）。
datetime.day - 介于 1 和给定年份的给定月份的天数之间。
datetime.hour - 在范围内(24)
datetime.min - 在范围内（60）
datetime.second - 在范围内(60)
datetime.microsecond - 在范围（1000000）内。
datetime.tzinfo - 作为 tzinfo 参数传递给 datetime 构造函数的对象，如果没有传递则为 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

类方法

Today() - 返回当前本地日期时间，tzinfo 无。
now(tz=None) - 返回当前本地日期和时间。
utcnow() - 返回当前 UTC 日期和时间，tzinfo None。
utcfromtimestamp(timestamp) - 返回与 POSIX 时间戳相对应的 UTC 日期时间，其中 tzinfo None
fromtimestamp(timestamp, timezone.utc) - 在 POSIX 兼容平台上，它相当于 datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(seconds=timestamp)
fromordinal(ordinal) - 返回对应于预推格里高利序数的日期时间，其中第 1 年的 1 月 1 日的序数为 1。
fromisoformat(date_string) - 返回与任何有效 ISO 8601 格式的 date_string 相对应的日期时间。

实例方法

date() - 返回具有相同年、月、日的日期对象。
time() - 返回具有相同小时、分钟、秒、微秒和折叠的时间对象。
timetz() - 返回具有相同小时、分钟、秒、微秒、折叠和 tzinfo 属性的时间对象。另请参见方法 time()。
Replace() - 返回具有相同属性的日期时间，但通过指定的关键字参数给出新值的属性除外。
astimezone(tz=None) - 返回具有新 tzinfo 属性 tz 的日期时间对象
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() 返回的时间。
atetime.toordinal() - 返回日期的预推格里高利序数。
timestamp() - 返回与日期时间实例对应的 POSIX 时间戳。
isoweekday() - 以整数形式返回一周中的某一天，其中星期一为 1，星期日为 7。
isocalendar() - 返回包含三个组成部分的命名元组：年、周和工作日。
isoformat(sep='T', timespec='auto') - 返回表示 ISO 8601 格式的日期和时间的字符串
__str__() - 对于日期时间实例 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

时间增量

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.min - 最负的 timedelta 对象，timedelta(-999999999)。
timedelta.max - 最正的 timedelta 对象，timedelta(天=999999999，小时=23，分钟=59，秒=59，微秒=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对象的唯一实例属性。

天- -999999999 和 999999999 之间（含）
秒- 0 到 86399 之间（含）
微秒- 0 到 999999 之间（含）

实例方法

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