Python 日期和时间

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

DateTime模块
Time模块
Calendar模块

什么是Tick间隔

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

在Python中有一个流行的 time 模块，它提供了处理时间和转换表示之间的函数。函数 time.time() 返回自1970年1月1日午夜12:00以来的当前系统时间的tick数。

示例

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

日期计算使用ticks非常容易。然而，这种形式无法表示纪元之前的日期。未来的日期也无法以这种方式表示——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表示库确定是否使用夏令时

获取当前时间

要将一个时间点从以浮点数表示的秒数（自纪元以来）转换为时间元组，将浮点数传递给一个函数（例如，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

获取一个月的日历

日历模块提供了许多方法来操作年历和月历。在这里，我们打印出给定月份（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中有一个流行的 time 模块，它提供了处理时间和转换表示之间的函数。这是所有可用方法的列表。

序号	功能及说明
1	time.altzone 如果定义了本地DST时区，返回本地DST时区相对于UTC的偏移量（以秒为单位）。如果本地DST时区在UTC的东面（如西欧和英国），则为负数。只有在夏令时非零时才使用此功能。
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时间的时间元组t。注意：t.tm_isdst始终为0
6	time.localtime([secs]) 接受一个自纪元以来的秒数表示的时间瞬间，返回一个带有本地时间的时间元组t（t.tm_isdst为0或1，取决于是否根据当地规则应用夏令时于时间瞬间secs）。
7	time.mktime(tupletime) 接受一个以本地时间表达的时间元组，返回一个以自纪元以来的秒数表示的浮点数。
8	time.sleep(secs) 暂停调用线程secs秒。
9	time.strftime(fmt[,tupletime]) 接受一个以本地时间表达的时间元组，并根据字符串fmt的指定返回表示该时间的字符串。
10	time.strptime(str,fmt=’%a %b %d %H:%M:%S %Y’) 根据格式字符串fmt解析str，并以时间元组的格式返回该时间瞬间。
11	time.time( ) 返回当前时间瞬间，以浮点数形式表示，单位为秒。
12	time.tzset() 重置库函数使用的时间转换规则。环境变量TZ指定如何进行重置。

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

time模块提供了两个重要的属性，它们是：

编号	属性及其描述
1	time.timezone 属性time.timezone是本地时区（无夏令时）与UTC的偏移量（在美洲大于0，在大部分欧洲、亚洲、非洲小于等于0）的秒数。
2	time.tzname 属性time.tzname是一个依赖于语言环境的字符串对，分别是不含和含夏令时的本地时区名称。

日历模块

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

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

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

序号	功能与描述
1	calendar.calendar(year,w=2,l=1,c=6) 返回一个用三列分隔而且每列中的日期由c个空格分隔的年份为year的多行字符串。w 是每个日期的字符宽度；每行的长度为21w+18+2c。l 是每周的行数。
2	calendar.firstweekday( ) 返回每周的起始日期设置的当前设置。默认情况下，当导入calendar时，这个值为0，表示星期一。
3	calendar.isleap(year) 如果year是闰年，则返回True；否则返回False。
4	calendar.leapdays(y1,y2) 返回范围（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；月份内的日子设置为它们的月份第一天和以后的天数。
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的反函数：接受以时间元组形式表示的时间瞬间，并将同一瞬间转换为自纪元以来的浮点秒数。
12	calendar.weekday(year, month, day) 返回给定日期的星期代码。星期代码为0（星期一）到6（星期日）；月份编号为1（一月）到12（十二月）。

日期时间模块

Python的日期时间模块包含在标准库中。它包含用于操作日期时间数据和执行日期时间运算的类。

日期时间类的对象可以是有意识的（aware）或者天真的（naïve）。如果对象包含时区信息，则为有意识的；否则为天真的。日期类的对象是天真的，而时间和日期时间对象是有意识的。

日期

日期对象表示带有年、月和日的日期。当前的公历可以无限期地向两个方向延伸。

语法

datetime.date(year, month, day)

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

year − MINYEAR ≤ 年份 ≤ MAXYEAR
month − 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子类的实例。其余的参数必须是以下范围内的整数 −

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 - 非相等时间对象之间可能的最小差异。

示例

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

会产生以下输出 output −

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

实例属性

time.hour − 在范围(24)内
time.minute − 在范围(60)内
time.second − 在范围(60)内
time.microsecond − 在范围(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

实例方法

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)

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

year： MINYEAR <= 年 <= MAXYEAR，
month： 1 <= 月 <= 12，
day： 1 <= 日 <= 给定月份和年份的天数，
hour： 0 <= 小时 < 24，
minute： 0 <= 分钟 < 60，
second： 0 <= 秒 < 60，
microsecond： 0 <= 微秒 < 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（MINYEAR, 1, 1, tzinfo = None）。
datetime.max - 可表示的最晚时间，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.year - 在MINYEAR和MAXYEAR之间（包括边界）。
datetime.month - 在1到12之间（包括边界）。
datetime.day - 在给定年份给定月份的天数范围内（1到该月份的天数）。
datetime.hour - 在范围(24)内。
datetime.minute - 在范围(60)内。
datetime.second - 在范围(60)内。
datetime.microsecond - 在范围(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

类方法

today() - 返回当前本地日期和时间，时区信息为None。
now(tz=None) - 返回当前本地日期和时间。
utcnow() - 返回当前UTC日期和时间，时区信息为None。
utcfromtimestamp(timestamp) - 返回与POSIX时间戳相对应的UTC日期和时间，时区信息为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() − 返回具有相同小时、分钟、秒、毫秒和fold的时间对象。
timetz() − 返回具有相同小时、分钟、秒、毫秒、fold和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.localtime()的time.struct_time。
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(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对象的唯一实例属性。

days − 范围在-999999999至999999999之间（包括）
seconds − 范围在0至86399之间（包括）
microseconds − 范围在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)

它将产生以下输出 −