第七章 datetime模块

1. datetime模块介绍

datetime 模块中提供了多种操作日期和时间的类，还提供了一系列由简单到复杂的日期时间处理方法，可以实现以各种不同方式创建和输出日期与时间信息。另外，本模块中还包含对时区及夏令时信息的处理方法。

2. datetime中的常量

datetime 模块提供两个常量MINYEAR 与MAXYEAR，分别用于表示date 或者datetime 对象所允许的最小年份与最大年份。语法格式如下：

datetime.MINYEAR

datetime.MAXYEAR

参数说明：

返回值：MINYEAR常量的返回值为1，MAXYEAR 常量的返回值为9999。

通过datetime 模块直接调用MINYEAR 与MAXYEAR 常量，获取date 或datetime 对象允许的最小与最大年份，代码如下：

import datetime 				# 导入datetime模块

print(‘date或datetime对象允许的最小年份为：',datetime.MINYEAR)

print(‘date或datetime对象允许的最大年份为：',datetime.MAXYEAR)

3. date类

datetime.date 类由year、month 及day 构成。datetime.date 类的定义如下：

datetime.date(year,month,day)

参数说明：

year ：必须参数，年，取值范围：[1, 9999]。
month：必须参数，月，取值范围：[1, 12]。
day ：必须参数，一月中第几天，取值范围：[1, 指定年份的月份中的天数]，最大值根据给定的year 和month 参数来决定。
返回值：返回year-month-day格式的日期对象。

说明:如果我们传递的参数超出取值范围，会抛出ValueError 异常。

通过设置年、月、日参数，创建一个date 对象，代码如下：

import datetime             				# 导入日期时间模块

print(datetime.date(2020,8,1))  			# 打印date对象

程序运行结果如下：

2020-08-01

datetime.date 对象提供了year、month 以及day 属性，分别用于获取日期对象中的年、月、日，代码如下：

import datetime                 			# 导入日期时间模块

date_object=datetime.date(2020,6,1) 		# 创建日期对象

print(‘日期对象的年为：',date_object.year)

print(‘日期对象的月为：',date_object.month)

print(‘日期对象的日为：',date_object.day)

程序运行结果如下：

日期对象的年为： 2020

日期对象的月为： 6

日期对象的日为： 1

datetime.date 对象提供了resolution、max 以及min 属性，分别用于获取日期对象中的最小单位、最大值和最小值，代码如下：

import datetime                         	# 导入日期时间模块

print(datetime.date.min)              		# 打印日期最小值

print(datetime.date.max)              		# 打印日期最大值

print(datetime.date.resolution)       		# 打印日期最小单位

4. format()方法——返回指定格式的日期字符串

date 类中的__format__() 方法与strftime() 方法相同，用于获取指定格式的日期字符串。语法格式如下：

date对象名.__format__()

参数说明：

返回值：返回指定格式的日期字符串。

使用__format__() 方法获取指定格式的日期字符串，代码如下：

from datetime import date    						# 导入datetime模块中的date类

date_object = date(2020,7,13) 						# 创建指定日期的date对象

print(date_object.__format__(‘%Y-%m-%d %a %B’)) 	# 打印以“-”分隔的日期字符串

print(date_object.__format__(‘%Y/%m/%d %a %B’)) 	# 打印以“/”分隔的日期字符串

print(date_object.__format__(‘%Y %m %d %a %B’)) 	# 打印以“ ”分隔的日期字符串

5. str()方法——返回“YYYY-MM-DD”格式的日期字符串

date 类中的__str__() 方法与isoformat() 方法相似，用于获取日期对象的日期字符串。语法格式如下：

date对象名.__str__()

参数说明：

返回值：根据指定的日期对象获取指定格式的日期字符串。

使用__str__() 方法获取日期对象的日期字符串，代码如下：

from datetime import date    				# 导入datetime模块中的date类

date_object = date(2020,8,13) 				# 创建指定日期的date对象

print(date_object.\_\_str\_\_())  			# 打印返回的日期字符串

print(str(date_object)+’类型为：',type(date_object))

print(date_object.\_\_str\_\_()+’类型为：',type(date_object.\_\_str\_\_()))

6. ctime()方法——返回包含时间的日期字符串

date 类中的ctime() 方法用于根据指定的日期对象获取包含时间的日期字符串。语法格式如下：

date对象名.ctime()

参数说明：

返回值：根据指定的日期对象获取指定格式的日期字符串。

使用ctime() 方法获取2020 年4 月20 日包含时间的日期字符串，代码如下：

from datetime import date    		# 导入datetime模块中的date类

date_object = date(2020,4,20) 		# 创建指定日期的date对象

print(date_object.ctime())    		# 打印包含时间的日期字符串

7. fromisoformat()方法——根据日期返回对应的date对象

date 类中的fromisoformat() 方法用于获取指定字符串日期对应的日期对象。语法格式如下：

date.fromisoformat（date_string）

参数说明：

date_string：表示指定的字符串日期，其格式为YYYY-MM-DD。
返回值：返回指定字符串日期对应的日期对象。

使用fromisoformat() 方法获取指定字符串日期对应的日期对象，代码如下

from datetime import date            			# 导入datetime模块中的date类

print(date.fromisoformat(‘2020-06-13’)) 		# 打印指定字符串日期对应的日期对象

8. fromordinal()方法——根据指定的天数返回对应的date对象

date 类中的fromordinal() 方法用于获取指定天数对应的date 对象，其中第1 年1 月1 日的序数为1。语法格式如下：

date.fromordinal(ordinal)

参数说明：

ordinal ：指定的天数。
返回值：返回指定天数对应的date对象，其中第1 年1 月1 日的序数为1。

使用fromordinal() 方法获取指定天数对应的日期，代码如下：

from datetime import date 			# 导入datetime模块中的date类

print(date.fromordinal(1)) 			# 打印第1天对应的日期对象

9. fromtimestamp()方法——根据时间戳返回 date对象

date 类中的fromtimestamp() 方法用于获取指定时间戳对应的date 对象。语法格式如下：

date.fromtimestamp（timestamp）

参数说明：

timestamp：指定的时间戳。
返回值：返回指定时间戳对应的date 对象。

使用fromtimestamp() 方法获取指定时间戳的date 对象，代码如下：

from datetime import date          			# 导入datetime模块中的date类

import time                     			# 导入时间模块

print(date.fromtimestamp(time.time())) 		# 打印当前时间戳对应的date对象

10. isocalendar()方法——返回包含年份、周数、星期数的元组

date 类中的isocalendar() 方法用于根据指定的日期对象获取对应的年份、周数、星期数所组成的元组。语法格式如下：

date对象名.isocalendar()

参数说明：

返回值：根据指定的日期对象返回对应的年份、周数、星期数所组成的元组。

使用isocalendar() 方法获取2020 年2 月27 日对应的年份、周数以及星期数，代码如下：

from datetime import date           			# 导入datetime模块中的date类

date_object = date(2020,2,27)        			# 创建指定日期的date对象

date_tuple = date_object.isocalendar()  		# 日期对应的年份、周数以及星期数元组

print(str(date_tuple[0])+’年')

print(‘第'+str(date_tuple[1])+’周')

print(‘星期'+str(date_tuple[2]))

11. isoformat()方法——返回“YYYY-MM-DD”格式的日期字符串

date 类中的isoformat() 方法返回指定的日期对象对应的“YYYY-MM-DD”格式的日期字符串。语法格式如下：

date对象名.isoformat()

参数说明：

返回值：指定日期对象的“YYYY-MM-DD”格式的日期字符串。

使用isoformat() 方法获取2020 年4 月12 日对应的日期字符串，代码如下：

from datetime import date    			# 导入datetime模块中的date类

date_object = date(2020,4,12) 			# 创建指定日期的date对象

print(str(date_object)+’类型为：',type(date_object))

print(date_object.isoformat()+’类型为：',type(date_object.isoformat()))

12. isoweekday()方法—— 返回当前日期的星期序号

date 类中的isoweekday() 方法用于获取指定日期对象的星期序号。语法格式如下：

date日期对象.isoweekday()

参数说明：

返回值：返回指定日期对象的星期序号。

使用isoweekday() 方法获取指定日期对象的星期序号，代码如下：

from datetime import date      		# 导入datetime模块中的date类

date_object = date(2020,3,8)   		# 创建指定日期的date对象

print(str(date_object)+’为 星期'+str(date_object.isoweekday()))

13. replace()方法——替换并返回新日期对象

date 类中的replace() 方法用于在不改变原日期对象的情况下替换并返回新的日期对象。语法格式如下：

date对象名.replace(year=self.year, month=self.month, day=self.day)

参数说明：

year ：表示需要替换的年份。
month：表示需要替换的月份。
day ：表示需要替换的天（日）。
返回值：替换并返回一个新的date对象。

使用replace() 方法实现替换并返回一个新的date 对象，代码如下：

from datetime import date      								# 导入datetime模块中的date类

date_object = date(2019,5,1)   								# 创建指定日期的date对象

print(‘原对象：',date_object)    							# 打印原date对象

print(‘新对象：',date_object.replace(2020,5,7)) 				# 打印替换后的新date对象

print(‘原对象id为：',id(date_object))

print(‘新对象id为：',id(date_object.replace(2020,5,7)))

14. strftime()方法——返回指定格式的日期字符串

date 类中的strftime() 方法用于获取指定格式的日期字符串。语法格式如下：

date对象名.strftime(format)

参数说明：

format ：指定日期所显示的格式。
返回值：返回指定格式的日期字符串。

使用strftime() 方法获取指定格式的日期字符串，代码如下：

from datetime import date                  			# 导入datetime模块中的date类

date_object = date(2020,8,13)               		# 创建指定日期的date对象

print(date_object.strftime(‘%Y-%m-%d %a %B’)) 		# 打印指定格式的日期字符串

15. timetuple()方法——返回日期对应的时间元组

date 类中的timetuple() 方法用于获取指定日期对应的时间元组。语法格式如下：

date对象名.timetuple()

参数说明：

返回值：根据指定的日期对象返回对应的时间元组。

使用timetuple() 方法获取日期对象的时间元组，代码如下：

from datetime import date     			# 导入datetime模块中的date类

date_object = date(2020,5,1)  			# 创建指定日期的date对象

print(date_object.timetuple())			# 打印日期对象对应的时间元组

16. today()方法——获取当前本地日期的date对象

date 类中的today() 方法用于返回当前的本地日期，相当于date.fromtimestamp(time.time())。语法格式如下：

date.today()

参数说明：

返回值：返回当前的本地日期。

使用today() 方法获取当前本地日期的date 对象，代码如下：

from datetime import date  			# 导入datetime模块中的date类

print(date.today())        			# 打印当前本地日期

17. toordinal()方法——返回自1年1月1日开始的第多少天

date 类中的toordinal() 方法用于获取自0001 年01 月01 日开始至指定日期对象的天数。语法格式如下：

date对象名.toordinal()

参数说明：

返回值：返回自0001 年01 月01 日开始至指定日期对象的天数。

使用toordinal() 方法获取自0001 年01 月01 日开始至指定日期对象的天数，代码如下：

from datetime import date      		# 导入datetime模块中的date类

date_object = date(2020,1,1)   		# 创建指定日期的date对象

print(date_object.toordinal()) 		# 打印自0001年01月01日开始至指定日期对象的天数

18. weekday()——获取指定日期的星期码

date 类中的weekday() 方法用于获取指定日期对象的星期码，星期一为0，星期日为6。语法格式如下：

date对象名.weekday()

参数说明：

返回值：返回指定日期对象的星期码，星期一为0，星期日为6。

使用weekday() 方法获取指定日期对象对应的星期几的值，代码如下：

from datetime import date                  		# 导入datetime模块中的date类

# 星期列表

week_list = [‘星期一',’星期二',’星期三',’星期四',’星期五',’星期六',’星期日']

date_object = date(2020,8,13)              		# 创建指定日期的date对象

week_code = date_object.weekday()          		# 获取指定日期对应的星期码

print(date_object,’为',week_list[week_code])	# 打印指定日期为星期几

19. datetime类

datetime 类可以看作是date 类和time 类的合体，其大部分的方法和属性都继承于这两个类，其数据构成也是由这两个类的所有属性组成的，datetime.datetime 类的定义如下：

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

参数说明：

year ：必须参数，表示年，取值范围：[MINYEAR, MAXYEAR]，即[1, 9999]。
month：必须参数，表示月，取值范围：[1, 12]。
day ：必须参数，表示一月中第几天，取值范围：[1, 指定年份的月份中的天数]，最大值根据给定的year 和month 参数来决定。
hour ：必须参数，表示小时，取值范围为[0, 23]。
minute：可选参数，表示分钟，取值范围为[0, 59]。
second：可选参数，表示秒，取值范围为[0, 59]。
microsecond：可选参数，表示微秒，取值范围为[0, 999999]。
tzinfo ：可选参数，表示时区的相关信息，tzinfo 为子类对象（如timezone类）的实例。
fold ：值为0 或1，默认为0。

说明:如果设定的值超过datetime.datetime 类参数的取值范围，就会引起ValueError 异常。

使用datetime 类对象提供的属性获取年、月、日、时、分、秒及微秒信息，代码如下：

from datetime import datetime 		# 导入datetime模块中的datetime类

dt=datetime.today()           		# 把获取的当前本地日期时间赋给变量dt

print(dt)                     		# 打印当前本地日期时间

print(dt.year,’年')

print(dt.month,’月')

print(dt.day,’日')

print(dt.hour,’时')

print(dt.minute,’分')

print(dt.second,’秒')

print(dt.microsecond,’微秒')

print(dt.tzinfo,’时区')

使用datetime 类对象提供的属性获取日期时间的最小值、最大值与最小单位，代码如下：

from datetime import datetime 			# 导入datetime模块中的datetime类

dt=datetime.today()           			# 把获取的当前本地日期时间赋给变量dt

print(‘最大值：',dt.max)

print(‘最小值：',dt.min)

print(‘最小单位：',dt.resolution)

20. format()方法——返回指定格式的日期字符串

datetime 类中的__format__() 方法与strftime() 方法相似，用于返回指定格式的日期时间字符串。语法格式如下：

datetime对象名.\_\_format (format)

参数说明：

format ：表示指定的显示格式。
返回值：返回以指定格式表示的日期时间字符串。

使用__format__() 方法获取指定格式的日期字符串，代码如下：

from datetime import datetime   			# 导入datetime模块中的datetime类

dt = datetime.today()           			# 获取当前日期时间

print(dt.__format__(‘%Y-%m-%d’)) 		# 打印指定格式的日期字符串

21. str()方法——返回“YYYY-MM-DD” 格式的日期字符串

datetime 类中的__str__() 方法与isoformat() 方法相似，用于返回“YYYY-MM-DD”格式的日期字符串。语法格式如下：

datetime对象名.__str__()

参数说明：

返回值：返回“YYYY-MM-DD”格式的日期字符串。

使用__str__() 方法获取日期时间对象所对应的字符串，代码如下：

from datetime import datetime 		# 导入datetime模块中的datetime类

dt = datetime.today()         		# 获取当前日期时间

print(dt.__str__())           		# 打印日期时间对象所对应的字符串

22. astimezone()方法——返回一个带有时区信息的datetime对象

datetime 类中的astimezone() 方法用于获取一个带有时区信息的datetime 对象，或者将datetime对象从一个时区转换到另一个时区。语法格式如下：

datetime对象名.astimezone(tz=None)

参数说明：

tz ：表示需要更换的时区，默认值为None。
返回值：返回一个带有时区信息的datetime对象。

使用astimezone() 方法获取带有时区信息的datetime 对象，代码如下：

from datetime import datetime 		# 导入datetime模块中的datetime类

dt=datetime.today()           		# 把获取的当前本地日期时间赋给变量dt

print(dt.astimezone())        		# 打印带有时区信息的datetime对象

程序运行结果如下：

2020-03-10 15:50:40.746350+08:00

使用astimezone() 方法将datetime 对象从一个时区转换到另一个时区，代码如下：

import datetime                                                	# 导入datetime模块

reduce_four = datetime.timezone(datetime.timedelta(hours=-4))  	# 创建-4时区对象

plus_four = datetime.timezone(datetime.timedelta(hours=4))     	# 创建+4时区对象

dt = datetime.datetime.today()                                 	# 本地时区信息的datetime对象

print(dt.astimezone(reduce_four))                              	# 修改为-4的时区信息

print(dt.astimezone(plus_four))                                	# 修改为+4的时区信息

23. combine()方法——将date和time对象合为datetime对象

datetime 类中的combine() 方法用于将date 对象和time 对象合为一个datetime 对象。语法格式如下：

datetime对象名.combine(date,time,tzinfo=self.tzinfo)

参数说明：

date：表示需要指定的date对象。
time：表示需要指定的time对象。
tzinfo ：表示时区信息对象。
返回值：返回将date对象与time对象组合后的新对象。

使用combine() 方法将date 对象和time 对象合为一个datetime 对象，代码如下：

from datetime import datetime   		# 导入datetime模块中的datetime类

from datetime import date       		# 导入datetime模块中的date类

from datetime import time       		# 导入datetime模块中的time类

d = date(2020,6,14)             		# 创建日期对象

t = time(14,11)                 		# 创建时间对象

print(datetime.combine(d,t))    		# 打印合并后的datetime对象

24. ctime()方法——返回一个代表日期和时间的字符串

datetime 类中的ctime() 方法用于返回一个代表日期和时间的字符串。语法格式如下：

datetime对象名.ctime()

参数说明：

返回值：返回一个代表日期和时间的字符串。

使用ctime() 方法获取代表日期和时间的字符串，代码如下：

from datetime import datetime 		# 导入datetime模块中的datetime类

dt = datetime.today()         		# 获取当前日期时间

	print(dt)                     	# 打印当前的日期时间

print(dt.ctime())             		# 打印包含日期和时间的字符串

25. date()方法——返回日期对象

datetime 类中的date() 方法用于获取日期时间对象中日期部分的date 对象。语法格式如下：

datetime对象名.date()

参数说明：

返回值：返回日期时间对象中日期部分的date 对象。

使用date() 方法获取日期时间对象中日期部分的date 对象，代码如下：

from datetime import datetime 		# 导入datetime模块中的datetime类

dt = datetime.today()         		# 获取当前日期时间

print(dt)                     		# 打印日期时间

print(dt.date())              		# 打印日期时间对象中的日期部分

print(type(dt))             		# 打印日期时间的类型

print(type(dt.date()))       		# 打印日期部分的类型

26. dst()方法——返回datetime对象的 dst偏移量

datetime 类中的dst() 方法用于获取datetime 实例对象中的dst（夏令时）偏移量。语法格式如下：

datetime对象名.dst(tz)

参数说明：

返回值：如果datetime 实例对象中指定了tz 参数，并且该参数的时区为夏令时，将返回dst（夏令时）偏移量对应的timedelta 对象；如果tz 参数所设置的时区不是夏令时则返回0:00:00 ；如果datetime 实例对象未设置tz 参数，则返回None。

使用dst() 方法获取datetime 对象的dst（夏令时）偏移量，代码如下：

import datetime                                       			# 导入datetime模块

from dateutil.tz import gettz                           		# 导入获取指定时区的方法

dt1 = datetime.datetime.now(tz=gettz(‘China Standard Time’))	# 获取中国标准时间时区

dt2 = datetime.datetime.now(tz=gettz(‘Pacific/Kiritimati’)) 	# 获取太平洋 圣诞岛时区

dt3 = datetime.datetime.now(tz=gettz(‘Australia/Sydney’))   	# 澳大利亚 悉尼时区

dt4 = datetime.datetime.now(tz=gettz(‘Europe/Madrid’))      	# 获取欧洲 马德里时区

dt5 = datetime.datetime.now(tz=gettz(‘America/Toronto’))    	# 获取美国 多伦多时区

print(‘中国标准时间时区:’,dt1)

print(‘夏令时偏移量：',dt1.dst())

print(‘太平洋 圣诞岛时区:’,dt2)

print(‘夏令时偏移量：',dt2.dst())

print(‘澳大利亚 悉尼时区:’,dt3)

print(‘夏令时偏移量：',dt3.dst())

print(‘欧洲 马德里时区',dt4)

print(‘夏令时偏移量：',dt4.dst())

print(‘美国 多伦多时区',dt5)

print(‘夏令时偏移量：',dt5.dst())

27. fromisoformat()方法——将日期时间字符串转换为datetime对象

datetime 类中的fromisoformat() 方法用于返回指定的日期时间字符串对应的datetime 对象。语法格式如下：

datetime对象名.fromisoformat(date_string)

参数说明：

date_string：表示指定的日期时间字符串。
返回值：返回对应的datetime对象。

使用fromisoformat() 方法返回指定的日期时间字符串对应的datetime 对象，代码如下：

from datetime import datetime 		# 导入datetime模块中的datetime类

dt = datetime.now()           		# 获取当前的日期时间对象

str_dt = dt.isoformat()       		# 获取日期时间字符串

# 打印指定的日期时间字符串对应的datetime对象

print(datetime.fromisoformat(str_dt))

28. fromordinal()方法——将公历序数转换为datetime对象

datetime 类中的fromordinal() 方法用于返回给定的公历序数对应的 datetime 对象实例，其中0001年的1 月1 日的序数为1。语法格式如下：

datetime对象名.fromordinal(ordinal)

参数说明：

ordinal ：表示日期公历序数，即自0001 年01 月01 日开始的第多少天。
返回值：返回给定的公历序数对应的 datetime 对象。

使用fromordinal() 方法获取指定公历序数对应的datetime 对象，代码如下：

from datetime import datetime   		# 导入datetime模块中的datetime类

from datetime import date       		# 导入datetime模块中的date类

od = date.today().toordinal()   		# 获取自0001年01月01日开始的第多少天

print(datetime.fromordinal(od)) 		# 打印公历序数对应的datetime对象

29. fromtimestamp()方法——根据时间戳创建datetime对象

datetime 类中的fromtimestamp() 方法用于根据指定的时间戳创建一个datetime 对象。语法格式如下：

datetime.fromtimestamp（timestamp，tz = None ）

参数说明：

timestamp：指定的时间戳。
tz ：指定时区信息。
返回值：返回一个datetime对象。

根据指定的时间戳创建一个datetime 对象并输出，代码如下：

from datetime import datetime             		# 导入datetime模块中的datetime类

import time                              		# 导入时间模块

print(datetime.fromtimestamp(time.time())) 		# 根据当前时间戳创建datetime对象

30. isocalendar()方法——返回包含年、周、星期的元组

datetime 类中的isocalendar() 方法用于返回一个包含给定日期时间对象的ISO year、ISO weeknumber 和ISO weekday 的元组。语法格式如下：

datetime对象名.isocalendar()

参数说明：

返回值：返回一个包含给定日期时间对象的ISO year、ISO week number和ISO weekday的元组。

使用isocalendar() 方法获取包含年份、周数、星期数的元组，代码如下：

from datetime import datetime 		# 导入datetime模块中的datetime类

dt = datetime.today()         		# 获取当前日期时间

print(dt.isocalendar())       		# 打印当前日期的年份、周数、星期数的元组

31. isoformat()方法——返回“YYYY-MM-DD”格式的日期时间字符串

datetime 类中的isoformat() 方法用于返回一个“YYYY-MM-DD”格式的日期时间字符串。语法格式如下：

datetime对象名.isoformat（sep ='T'，timespec='auto'）

参数说明：

sep：可选参数，默认值为T，是一个单字符分隔符，用来分隔结果中的日期和时间部分。
timespec：可选参数，默认值为auto。还可设置为以下参数：
Ø auto ：如果microseconds 为0，则与seconds 相同，否则与microseconds 相同。
Ø hours ：两位数的hour，采用HH 格式。
Ø minutes ：包含hour、minute，采用HH ：MM 格式。
Ø seconds ：包含hour、minute 和second，采用HH ：MM ：SS 格式。
Ø milliseconds ：包含全时，但将小数秒部分截断为毫秒，采用HH ：MM ：SS.sss 格式。
Ø microseconds ：采用HH ：MM ：SS.ffffff 格式的全时。
返回值：返回一个使用 ISO 8601 格式表示的datetime实例的日期和时间字符串。

使用isoformat() 方法获取日期时间对象所对应的字符串，代码如下：

from datetime import datetime 		# 导入datetime模块中的datetime类

dt = datetime.today()         		# 获取当前日期时间

print(dt.isoformat())         		# 打印日期时间对象所对应的字符串

32. isoweekday()方法——返回指定日期的星期序号

datetime 类中的isoweekday() 方法用于返回指定日期在一周内的序号，其中周一表示为1，周日表示为7。语法格式如下：

datetime对象名.isoweekday()

参数说明：

返回值：返回对象名指定日期在一周内的序号，其中周一表示为1，周日表示为7。

使用isoweekday() 方法获取当前日期的星期序号，代码如下：

from datetime import datetime 		# 导入datetime模块中的datetime类

dt = datetime.today()         		# 获取当前日期时间

print(dt.isoweekday())        		# 打印当前日期对应的星期序号

33. now()方法——返回指定时区的本地日期时间

datetime 类中的now() 方法用于返回一个表示当前本地时间的datetime 对象。语法格式如下：

datetime.now(tz=None)

参数说明：

tz：可选参数。如果提供了参数tz，则获取tz 所指时区的本地时间；如果不指定参数tz 或参数tz 为None，则结果和datetime.today() 结果相同。
返回值：返回一个表示当前本地日期时间的datetime对象。

分别使用today() 方法和now() 方法获取当前本地日期时间，代码如下：

from datetime import datetime 		# 导入datetime模块中的datetime类

print(datetime.today())       		# 通过today方法获取当前日期时间

print(datetime.now())         		# 通过now方法获取当前日期时间

34. replace()方法——替换并返回新datetime对象

datetime 类中的replace() 方法用于在不改变原日期时间对象的情况下替换并返回新的datetime 对象。语法格式如下：

datetime对象名.replace（year = self.year，month = self.month，day = self.day，hour =self.hour，minute = self.minute，second = self.second，microsecond = self.microsecond，tzinfo = self.tzinfo，*， fold = 0 ）

参数说明：

year ：表示需要替换的年份。
month：表示需要替换的月份。
day ：表示需要替换的天（日）。
hour ：表示需要替换的小时。
minute：表示需要替换的分钟。
second：表示需要替换的秒。
microsecond：表示需要替换的微秒。
tzinfo ：表示需要替换的时区信息。
fold ：0 或1，默认为0。
返回值：返回新的日期时间对象。

使用replace() 方法在不改变原日期时间对象的情况下替换并返回新的datetime 对象，代码如下：

from datetime import datetime               		# 导入datetime模块中的datetime类

dt = datetime.today()                        		# 获取当前日期时间

new_dt = dt.replace(2019,12,25,22,15,38,888) 		# 替换原对象获取新对象

print(‘原对象：',dt)

print(‘新对象：',new_dt)

print(‘原对象id为：',id(dt))

print(‘新对象id为：',id(new_dt))

35. strftime()方法——返回指定格式的日期时间字符串

datetime 类中的strftime() 方法用于返回指定格式的日期时间字符串。语法格式如下：

datetime对象名.strftime(format)

参数说明：

format ：表示指定的显示格式。
返回值：返回format 指定格式的日期时间字符串。

使用strftime() 方法获取指定格式的日期字符串，代码如下：

from datetime import datetime       		# 导入datetime模块中的datetime类

dt = datetime.today()               		# 获取当前日期时间

print(dt.strftime(“%d-%m-%y %H:%M”)) 		# 打印指定格式的日期字符串

print(dt.strftime(“%d/%m/%y %H:%M”))

print(dt.strftime(“%d %m %y %H:%M”))

36. strptime()方法——获取对应的datetime对象

datetime 类中的strptime() 方法用于根据指定的日期时间字符串与格式，获取对应的datetime 对象。语法格式如下：

datetime.strptime(date_string,format)

参数说明：

date_string：表示指定的日期时间字符串。
format ：表示指定日期时间字符串的格式。
返回值：返回指定格式的日期时间字符串对应的datetime对象。

使用strptime() 方法根据指定的日期时间字符串与格式获取对应的datetime 对象，代码如下：

from datetime import datetime 		# 导入datetime模块中的datetime类

dt = datetime.strptime(‘14/08/20 14:45’, ‘%d/%m/%y %H:%M’)

print(dt)                   		# 打印日期时间对象

37. time()方法——返回时间对象

datetime 类中的time() 方法获取时间对象。语法格式如下：

datetime对象名.time()

参数说明：

返回值：返回时间对象。

使用time() 方法获取时间对象，代码如下：

from datetime import datetime 		# 导入datetime模块中的datetime类

dt = datetime.today()        		# 获取当前日期时间

print(dt)                     		# 打印日期时间

print(dt.time())             		# 打印日期时间对象中的时间部分

print(type(dt))             		# 打印日期时间的类型

print(type(dt.time()))       		# 打印时间部分的类型

38. timestamp()方法——返回当前时间的时间戳

datetime 类中的timestamp() 方法用于获取当前日期时间对象所对应的时间戳。语法格式如下：

datetime对象名.timestamp()

参数说明：

返回值：返回当前日期时间对象所对应的时间戳。

使用timestamp() 方法获取当前日期时间对象所对应的时间戳，代码如下：

from datetime import datetime 		# 导入datetime模块中的datetime类

dt = datetime.today()         		# 获取当前日期时间

print(dt.timestamp())         		# 打印对应的时间戳

39. timetuple()方法——返回对应的时间元组

datetime 类中的timetuple() 方法用于获取日期时间对象所对应的时间元组。语法格式如下：

datetime对象名.timetuple()

参数说明：

返回值：返回对应的时间元组。

使用timetuple() 方法获取日期时间对象所对应的时间元组，代码如下：

from datetime import datetime  		# 导入datetime模块中的datetime类

dt = datetime.today()          		# 获取当前日期时间

print(dt.timetuple())         		# 打印对应的时间元组

40. timetz()方法——返回时区时间对象

datetime 类中的timetz() 方法用于获取日期时间对象所对应的时区时间。语法格式如下：

datetime对象名.timetz()

参数说明：

返回值：返回时区对应的时间对象。

使用timetz() 方法获取日期时间对象所对应的时区时间，代码如下：

from datetime import datetime  		# 导入datetime模块中的datetime类

dt=datetime.today()            		# 把获取的当前本地日期时间赋给变量dt

print(dt.timetz())            		# 打印日期时间对象对应的时区时间

41. today()方法——返回当前本地日期时间

datetime 类中的today() 方法用于返回一个表示当前本地日期时间的datetime 对象。语法格式如下：

datetime.today()

参数说明：

返回值：返回一个表示当前本地日期时间的datetime对象。

使用today() 方法获取当前本地日期时间，代码如下：

from datetime import datetime  		# 导入datetime模块中的datetime类

dt=datetime.today()           		# 把获取的当前本地日期时间赋给变量dt

print(dt)                    		# 打印当前本地日期时间

42. toordinal()方法——返回自0001年01月01日开始的第多少天

datetime 类中的toordinal() 方法用于获取自0001 年01 月01 日开始至当前日期时间对象的天数。语法格式如下：

datetime对象名.toordinal()

参数说明：

返回值：返回自0001 年01 月01 日开始至当前日期时间对象的天数。

使用toordinal() 方法获取自0001 年01 月01 日开始至当前日期时间的天数，代码如下：

from datetime import datetime  		# 导入datetime模块中的datetime类

dt = datetime.today()          		# 获取当前日期时间

print(dt.toordinal())          		# 打印自0001年01月01日开始至当前日期时间的天数

43. tzname()方法——返回时区名称

datetime 类中的tzname() 方法用于获取时区名称。语法格式如下：

datetime对象名.tzname()

参数说明：

返回值：如果datetime 实例对象中指定了tz 参数，将返回对应的时区名称。如果datetime 实例对象未设置tz 参数，则返回None。返回的时区名称可以是“GMT”“UTC”“500”“-5:00”以及“美国东部时间”等有效名称。

使用tzname() 方法获取datetime 实例对象中对应的时区名称，代码如下：

import datetime                                           		# 导入datetime模块

from dateutil.tz import gettz                              		# 导入获取指定时区的方法

dt1 = datetime.datetime.now(tz=gettz(‘China Standard Time’))   	# 获取中国标准时间时区

dt2 = datetime.datetime.now(tz=gettz(‘Pacific/Kiritimati’))    	# 获取太平洋 圣诞岛时区

dt3 = datetime.datetime.now(tz=gettz(‘Australia/Sydney’))      	# 澳大利亚 悉尼时区

dt4 = datetime.datetime.now(tz=gettz(‘Europe/Madrid’))         	# 获取欧洲 马德里时区

dt5 = datetime.datetime.now(tz=gettz(‘America/Toronto’))       	# 获取美国 多伦多时区

dt6 = datetime.datetime.now()                               	# 未指定时区

print(‘中国标准时间时区名称:’,dt1.tzname())

print(‘太平洋 圣诞岛时区名称:’,dt2.tzname())

print(‘澳大利亚 悉尼时区名称:’,dt3.tzname())

print(‘欧洲 马德里时区名称：',dt4.tzname())

print(‘美国 多伦多时区名称',dt5.tzname())

print(‘未指定时区：',dt6.tzname())

44. tzname()方法——返回时区名称

time 类中的tzname() 方法用于获取time 对象的时区名称。语法格式如下：

time对象名.tzname()

参数说明：

返回值：如果time 实例对象中指定了tzinfo 参数，将返回对应的时区名称；如果time 实例对象未设置tzinfo 参数，则返回None。返回的时区名称可以是“GMT”“UTC”“500”“-5:00”以及“美国东部时间”等有效名称。

使用tzname() 方法获取time 对象的时区名称，代码如下：

import datetime                                			# 导入datetime模块

# 创建名称为欧洲 马德里时区

timezone_madrid = datetime.timezone(datetime.timedelta(hours=2),name=’Europe/Madrid’)

# 创建-4时区

timezone_toronto = datetime.timezone(datetime.timedelta(hours=-4))

t1 = datetime.time(4,5,12,tzinfo=timezone_madrid)  		# 马德里时区的时间对象

t2 = datetime.time(4,5,12,tzinfo=timezone_toronto) 		# -4时区的时间对象

t3 = datetime.time(4,5,12)                      		# 未指定时区

print(t1.tzname())

print(t2.tzname())

print(t3.tzname())

45. utcfromtimestamp()方法——将时间戳转为UTC datetime对象

datetime 类中的utcfromtimestamp() 方法可以根据指定的时间戳创建一个UTC 时间的datetime 对象。语法格式如下：

datetime.utcfromtimestamp（timestamp）

参数说明：

timestamp：表示指定的时间戳。
返回值：返回一个UTC时间的datetime对象。

使用utcfromtimestamp() 方法，根据指定的时间戳创建一个UTC时间的datetime 对象，代码如下：

from datetime import datetime 			# 导入datetime模块中的datetime类

import time                  			# 导入时间模块

#以time.time()方法获取的时间戳为参数创建一个UTC时间的datetime对象

print(datetime.utcfromtimestamp(time.time()))

46. utcnow()方法——返回当前日期时间的 UTC datetime对象

datetime 类中的utcnow() 方法用于返回一个当前UTC 时间的datetime 对象。语法格式如下：

datetime.utcnow()

参数说明：

返回值：返回一个当前UTC时间的datetime对象。

使用utcnow() 方法获取当前的UTC 日期和时间，代码如下：

from datetime import datetime 			# 导入datetime模块中的datetime类

print(datetime.utcnow()) 				# 获取UTC时间

47. utcoffset()方法——返回datetime对象的 UTC偏移量

datetime 类中的utcoffset() 方法用于返回datetime 对象的UTC 偏移量。语法格式如下：

datetime对象名.utcoffset()

参数说明：

返回值：如果datetime实例对象中指定了tz 参数，将返回UTC 偏移量对应的timedelta对象；如果datetime 实例对象未设置tz 参数，则返回None。

使用utcoffset() 方法获取datetime 对象的UTC 偏移量，代码如下：

import datetime                                         		# 导入datetime模块

reduce_four = datetime.timezone(datetime.timedelta(hours=-4))	# 创建-4时区对象

plus_four = datetime.timezone(datetime.timedelta(hours=4))   	# 创建+4时区对象

dt = datetime.datetime.now(reduce_four)                    		# 获取-4时区本地日期时间对象

dt1 = datetime.datetime.now(plus_four)                     		# 获取+4时区本地日期时间对象

dt2 = datetime.datetime.now()                             		# 获取未设置时区本地日期时间对象

print(dt)                                               		# 打印-4时区本地日期时间

print(dt1)                                              		# 打印+4时区本地日期时间

print(dt2)                                              		# 打印未设置时区本地日期时间

print(dt.utcoffset())                                    		# 打印dt对象utc偏移量

print(dt1.utcoffset())                                   		# 打印dt1对象utc偏移量

print(dt2.utcoffset())                                   		# 打印dt2对象utc偏移量

48. utctimetuple()方法——返回UTC世界协调时的时间元组

datetime 类中的utctimetuple() 方法与timetuple() 类似，都可以用于获取时间元组信息。不同的是utctimetuple() 方法可以获取datetime 对象UTC 世界协调时的时间元组，在datetime 对象中无论设置什么时区，都将被强制设为0。语法格式如下：

datetime.utctimetuple()

参数说明：

返回值：返回datetime对象UTC世界协调时的时间元组。

使用utctimetuple() 方法获取datetime 对象UTC 世界协调时的时间元组，代码如下：

import datetime                                           		# 导入datetime模块

reduce_four = datetime.timezone(datetime.timedelta(hours=-4))  	# 创建-4时区对象

plus_four = datetime.timezone(datetime.timedelta(hours=4))     	# 创建+4时区对象

dt1 = datetime.datetime.now()                               	# 获取未设置时区本地日期时间对象

dt2 = datetime.datetime.now(reduce_four)                     	# 获取-4时区本地日期时间对象

dt3 = datetime.datetime.now(plus_four)                      	# 获取+4时区本地日期时间对象

print(dt1.timetuple())                                     		# 打印未设置时区的时间元组，默认北京时区+8

print(dt1.utctimetuple())                              			# 打印未设置时区UTC世界协调时的时间元组,默认北京时区+8

print(dt2.timetuple())                                 			# 打印-4时区的时间元组，tm_hour=当前小时-8-4

print(dt2.utctimetuple())                              			# 打印-4时区UTC世界协调时的时间元组，tm_hour=当前小时-8

print(dt3.timetuple())                                 			# 打印+4时区的时间元组，tm_hour=当前小时-4

print(dt3.utctimetuple())                              			# 打印+4时区UTC世界协调时的时间元组，tm_hour=当前小时-8

49. weekday()方法——获取星期对应的数字

datetime 类中的weekday() 方法用于返回指定日期在一周内的序号，其中周一表示为0，周日表示为6。语法格式如下：

datetime对象名.weekday()

参数说明：

返回值：返回指定日期在一周内的序号，其中周一表示为0，周日表示为6。

使用weekday() 方法获取当前日期中星期对应的数字，代码如下：

from datetime import datetime 		# 导入datetime模块中的datetime类

dt = datetime.today()        		# 获取当前日期时间

print(dt.weekday())          		# 打印当前日期中星期对应的数字

程序运行结果如下：

使用weekday() 方法获取指定日期中星期对应的数字，代码如下：

from datetime import datetime  		# 导入datetime模块中的datetime类

dt = datetime(2020,2,17)       		# 创建指定日期的datetime对象

print(dt.weekday())            		# 打印指定日期中星期对应的数字

50. time类

time 类由hour、minute、second、microsecond 和tzinfo 五部分组成，time 类的定义如下：

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

参数说明：

hour ：必须参数，表示小时，取值范围：[0, 23]。
minute：可选参数，表示分钟，取值范围：[0, 59]。
second：可选参数，表示秒，取值范围：[0, 59]。
microsecond：可选参数，表示微秒，取值范围：[0, 999999]。
tzinfo ：可选参数，表示时区的相关信息，tzinfo 为子类对象（如timezone类）的实例。
fold ：值为0 或1，默认为0。

说明:如果我们传递的参数超出取值范围，会抛出ValueError 异常。

使用time 类对象提供的属性获取时间对象的时、分、秒、微秒信息，代码如下：

from datetime import time                     		# 导入datetime模块中的time类

t=time(16,13,56,888)                           		# 创建时间对象

print(t)

print(t.hour,t.minute,t.second,t.microsecond)   	# 打印时、分、秒、微秒

程序运行结果如下：

16:13:56.000888

16 13 56 888

使用time 类对象提供的属性，获取时间对象的最大时间、最小时间以及时间的最小单位，代码如下：

from datetime import time 		# 导入datetime模块中的time类

print(time.max)          		# time类所能表示的最大时间

print(time.min)          		# time类所能表示的最小时间

print(time.resolution)    		# 两个不同时间的最小单位

程序运行结果如下：

23:59:59.999999

00:00:00

0:00:00.000001

使用time 类对象提供的tzinfo 属性，获取时间对象的时区信息对象，代码如下：

from datetime import time  		# 导入datetime模块中的time类

t=time(16,13,56,888)        	# 创建时间对象

print(t.tzinfo)                 # 在没有指定时区参数时，返回None

51. format()方法——返回时间字符串

time 类中的__format__() 方法与strftime() 方法相似，用于根据自定义的格式返回时间字符串。语法格式如下：

time对象名.__format__(format)

参数说明：

format ：表示自定义的时间格式。
返回值：返回时间字符串。

获取自定义格式的时间字符串

from datetime import time    		# 导入datetime模块中的time类

t=time(16,13,56,888)        		# 创建时间对象

print(t.\_\_format\_\_(‘%H’))    	# 打印小时

print(t.\_\_format\_\_(‘%H:%M’)) 	# 打印小时与分钟

52. str()方法——返回“HH:MM:SS.%f”格式的时间字符串

time 类中的__str__() 方法与isoformat() 方法相似，用于返回一个“HH:MM:SS.%f”格式的时间字符串。语法格式如下：

calendar.day_abbrtime对象名.__str__()

参数说明：

返回值：返回一个“HH:MM:SS.%f”格式的时间字符串。

使用__str__() 方法获取指定格式的时间字符串，代码如下：

from datetime import time   		# 导入datetime模块中的time类

t=time(16,13,56,888)       			# 创建时间对象

print(t.__str__())          		# 打印指定格式的时间字符串

54. fromisoformat()方法——将时间字符串转换为时间对象

time 类中的fromisoformat() 方法用于将时间字符串转换为时间对象。语法格式如下：

time对象名.fromisoformat(time_string)

参数说明：

time_string：指定的时间字符串。
返回值：返回时间字符串对应的时间对象。

使用fromisoformat() 方法获取指定时间字符串对应的时间对象，代码如下：

from datetime import time                    		# 导入datetime模块中的time类

t=time(16,13,56,888)                        		# 创建时间对象

time_str = t.isoformat()                     		# 获取时间字符串

print(time_str,’对应的类型为：',type(time_str))

time_object = time.fromisoformat(time_str)     		# 获取时间字符串对应的时间对象

print(time_object,’对应类型为：',type(time_object))

55. isoformat()方法——返回“HH:MM:SS.%f”格式的时间字符串

time 类中的isoformat() 方法用于返回一个“HH:MM:SS.%f”格式的时间字符串。语法格式如下：

time对象名.isoformat（timespec='auto'）

参数说明：

timespec：可选参数，默认值为auto。它可以设置为以下值：
Ø auto ：表示如果microsecond 为0，则与second 相同，否则与microsecond 相同。
Ø hours ：表示格式为HH，说明只显示小时。
Ø minutes ：表示格式为 HH:MM，说明只显示小时和分钟。
Ø seconds ：表示格式为 HH:MM:SS，说明只显示小时、分钟与秒。
Ø milliseconds ：表示时间格式为HH:MM:SS.sss，不会显示微秒。
Ø microseconds ：表示时间格式为HH:MM:SS.ffffff，完整的时间格式。
返回值：返回一个“HH:MM:SS.%f”格式的时间字符串。

使用isoformat() 方法获取指定格式的时间字符串，代码如下：

from datetime import time    		# 导入datetime模块中的time类

t=time(16,13,56,888)        		# 创建时间对象

print(t.isoformat())        		# 打印默认格式的时间字符串

print(t.isoformat('hours'))

print(t.isoformat('minutes'))

print(t.isoformat('seconds'))

print(t.isoformat('milliseconds'))

print(t.isoformat('microseconds'))

56. replace()方法——替换并返回新的时间对象

time 类中的replace() 方法用于在不改变原时间对象的情况下替换并返回新的时间对象。语法格式如下：

time对象名.replace(hour=self.hour, minute=self.minute, second=self.second,microsecond=self.microsecond, tzinfo=self.tzinfo, * fold=0)

参数说明：

hour ：表示需要替换的小时。
minute：表示需要替换的分钟。
second：表示需要替换的秒。
microsecond：表示需要替换的微秒。
tzinfo ：表示需要替换的时区信息。
fold ：值为0 或1，默认为0。
返回值：返回新的时间对象。

在不改变原时间对象的情况下替换并返回新的时间对象，代码如下：

from datetime import time         		# 导入datetime模块中的time类

t=time(16,13,56,888)              		# 创建时间对象

new_time=t.replace(16,28,40,567)  		# 替换时间对象

print(‘原对象：',t)

print(‘新对象：',new_time)

57. strftime()方法——根据自定义的格式返回时间字符串

time 类中的strftime() 方法用于根据自定义的格式返回时间字符串。语法格式如下：

time对象名.strftime(format)

参数说明：

format ：表示自定义的时间格式。
返回值：返回时间字符串。

使用strftime() 方法获取自定义格式的时间字符串，代码如下：

from datetime import time    		# 导入datetime模块中的time类

t=time(16,13,56,888)        		# 创建时间对象

print(t.strftime(‘%H’))      		# 打印小时

print(t.strftime(‘%H:%M’))   		# 打印小时与分钟

58. utcoffset()方法——返回time对象的 UTC偏移量

time 类中的utcoffset() 方法用于获取time 对象的UTC 偏移量。语法格式如下：

time对象名.utcoffset()

参数说明：

返回值：如果time 实例对象中指定了tzinfo 参数，将返回UTC 偏移量对应的timedelta 对象；如果datetime 实例对象未设置tzinfo 参数，则返回None。

使用utcoffset() 方法获取time 对象的UTC 偏移量，代码如下：

import datetime                                           		# 导入datetime模块

reduce_four = datetime.timezone(datetime.timedelta(hours=-4))  	# 创建-4时区对象

plus_four = datetime.timezone(datetime.timedelta(hours=4))     	# 创建+4时区对象

t1 = datetime.time(13,57,12,tzinfo=reduce_four)              	# -4时区time对象

t2 = datetime.time(13,57,12,tzinfo=plus_four)                	# +4时区time对象

t3 = datetime.time(13,57,12)                               		# 未设置时区time对象

print(t1.utcoffset()) 		# 打印t1对象的UTC偏移量

print(t2.utcoffset()) 		# 打印t2对象的UTC偏移量

print(t3.utcoffset()) 		# 打印t3对象的UTC偏移量

59. timedelta类

timedelta 类表示时间差，即两个日期或时间之间的差值。timedelta 类可以很方便地对datetime.date、datetime.time 和datetime.datetime 对象进行算术运算，且两个时间之间的差值单位也更加容易控制。这个差值的单位可以是：天、秒、微秒、毫秒、分钟、小时、周。datetime.timedelta 类的定义如下：

datetime.timedelta（days = 0，seconds = 0，microseconds = 0，milliseconds = 0，minutes =0，hours = 0，weeks = 0 ）

参数说明：

days：表示天，取值范围：[-999999999, 999999999]。
seconds：表示秒，取值范围：[0, 86399]。
microseconds：表示微秒，取值范围：[0, 999999]。
所有的参数都是可选参数，默认值为0，参数的值可以是整数或浮点数，可以是正数或负数。虽然参数可以传递的单位很多，但是Python 内部实现只存储了days、seconds 和microseconds 三种单位，其他单位在计算时都将被转换成相应的这3 种单位：
Ø 1 millisecond = 1000 microseconds。
Ø 1 minute = 60 seconds。
Ø 1 hour = 3600 seconds。
Ø 1 week = 7 days。

说明:在传递seconds 和microseconds 的时候，如果这两个参数超出取值范围，Python 会自动转换，但是如果days 超出取值范围，会抛出OverflowError 异常。

使用timedelta 类对象提供的min、max、resolution 属性获取三种时间差，代码如下：

from datetime import timedelta 		# 导入datetime模块中的timedelta类、

print(timedelta.max)          		# 打印正数最大时间差

print(timedelta.min)          		# 打印负数最小时间差

print(timedelta.resolution)    		# 打印两个时间的最小差值单位

程序运行结果如下：

999999999 days, 23:59:59.999999

-999999999 days, 0:00:00

0:00:00.000001

使用timedelta 类对象提供的days、seconds、microseconds 属性获取timedelta 类对象的天、秒与微秒的值，代码如下：

from datetime import timedelta  		# 导入datetime模块中的timedelta类

td = timedelta(365,888,687411)  		# 创建timedelta对象

print(td.days)                 			# 打印天

print(td.seconds)              			# 打印秒

print(td.microseconds)          		# 打印微秒

60. total_seconds()方法——获取时间差中包含的总秒数

timedelta 类中的total_seconds() 方法用于获取时间差中包含的总秒数，等价于timedelta(seconds=1)。语法格式如下：

timedelta对象名.total_seconds()

参数说明：

返回值：返回时间差中包含的总秒数。

使用total_seconds() 方法获取时间差中包含的总秒数，代码如下：

from datetime import timedelta 		# 导入datetime模块中的timedelta类

td = timedelta(365,888,687411) 		# 创建timedelta对象

print(td.total_seconds())      		# 打印时间差中包含的总秒数

60. timezone类

timezone 类是tzinfo 类的一个子类，它的每一个实例代表一个与UTC 的固定差值所定义的时区。注意，该类的对象不能用于表示某些特殊地点的时区信息。datetime.timezone 类的定义如下：

datetime.timezone(offset, name=None)

参数说明：

offset ：必须指定为一个timedelta 对象，表示本地时间与UTC 的差值。它必须严格限制于-timedelta（hours=24）和timedelta（hours=24）之间，否则会引发ValueError 异常。
name：可选参数，如果指定该参数则必须是一个字符串，它是由datetime.tzname() 方法获取的返回值。

首先使用timezone 类创建时区对象，然后通过time 类中的tzname() 方法获取自定义的时区名称，代码如下：

import datetime                                			# 导入datetime模块

# 创建名称为欧洲 马德里时区

timezone_madrid = datetime.timezone(datetime.timedelta(hours=2),name=’Europe/Madrid’)

# 创建-4时区

timezone_toronto = datetime.timezone(datetime.timedelta(hours=-4))

t1 = datetime.time(4,5,12,tzinfo=timezone_madrid)   	# 马德里时区的时间对象

t2 = datetime.time(4,5,12,tzinfo=timezone_toronto)  	# -4时区的时间对象

t3 = datetime.time(4,5,12)                        		# 未指定时区

print(t1.tzname())

print(t2.tzname())

print(t3.tzname())

61. utc属性——获取UTC时区

timezone 类中的utc 属性用于获取UTC 时区，即timezone(timedelta(0))。语法格式如下：

timezone对象名.utc

参数说明：

返回值：返回UTC时区，即timezone(timedelta(0))。

使用timezone 类中的utc 属性获取对应的UTC 时区，代码如下：

import datetime                      		# 导入datetime模块

# 创建名称为欧洲 马德里时区

timezone_madrid = datetime.timezone(datetime.timedelta(hours=2),name=’Europe/Madrid’)

# 创建-4时区

timezone_toronto = datetime.timezone(datetime.timedelta(hours=-4))

print(timezone_madrid.utc)            		# 打印名称为欧洲 马德里时区的UTC时区

print(timezone_toronto.utc)           		# 打印名-4时区的UTC时区

程序运行结果如下：

UTC

UTC

首先创建两个相同的time 对象，一个设置为自定义的马德里时区，另一个设置为马德里时区对象所对应的utc，然后分别打印两个time 对象内容，代码如下：

import datetime                                    			# 导入datetime模块

# 创建名称为欧洲 马德里时区

timezone_madrid = datetime.timezone(datetime.timedelta(hours=2),name=’Europe/Madrid’)

t_madrid = datetime.time(4,5,12,tzinfo=timezone_madrid)		# 为time对象设置自定义的马德里时区

# 为time对象设置自定义的马德里时区所对应的utc

t_utc = datetime.time(4,5,12,tzinfo=timezone_madrid.utc)

print(t_madrid)                                    			# 打印马德里时区的time对象

print(t_utc)                                      			# 打印马德里时区对应的UTC的time对象

程序运行结果如下：

04:05:12+02:00

04:05:12+00:00

说明:从锦囊2 的运行结果可以确认，无论timezone 对象中所设置UTC 偏移量是多少，其timezone 对象中的utc 属性都将返回UTC 协调世界时00:00。

62. dst()方法——总是返回None

timezone 类中的dst() 方法总是返回None。语法格式如下：

timezone对象名.dst(dt)

参数说明：

dt ：表示datetime实例对象。
返回值：dst() 方法正常是用于获取夏令时的偏移量，而调用timezone 类中的dst() 方法则总是返回None。

使用dst() 方法获取timezone 实例对象的dst，代码如下：

import datetime                      								# 导入datetime模块

# 创建名称为马德里时区

timezone_madrid = datetime.timezone(datetime.timedelta(hours=2),name=’Europe/Madrid’)

reduce_four = datetime.timezone(datetime.timedelta(hours=-4)) 		# 创建-4时区对象

dt = datetime.datetime.now(reduce_four)								# 创建一个使用-4时区的datetime对象

dt1 = datetime.datetime.now()         								# 未指定时区的datetime对象

print(timezone_madrid.dst(dt))        								# 打印自定义欧洲 马德里时区对象的dst

print(timezone_madrid.dst(dt1))        								# 打印自定义欧洲 马德里时区对象的dst

63. fromutc()方法——返回一个datetime对象

timezone 类中的fromutc() 方法用于获取一个包含datetime+offset 信息的datetime 对象。语法格式如下：

timezone对象名.fromutc(dt)

参数说明：

dt ：表示具有时区或夏令时的datetime实例对象，其tzinfo 值设为self（timezone对象自身）。
返回值：返回一个包含datetime+offset 信息的datetime对象。

使用fromutc() 方法获取包含datetime+offset 信息的datetime 对象，代码如下：

import datetime                             		# 导入datetime模块

# 创建名称为欧洲 马德里时区

timezone_madrid = datetime.timezone(datetime.timedelta(hours=2),name=’Europe/Madrid’)

dt = datetime.datetime.now(tz=timezone_madrid) 		# 指定马德里时区的datetime对象

print(dt)                                  			# 打印马德里当前时间

print(timezone_madrid.fromutc(dt))            		# 打印包含datetime+offset信息的datetime对象

64. tzname()方法——返回指定的name值

timezone 类中的tzname() 方法用于获取在构造timezone 实例时指定的name 值。语法格式如下：

timezone对象名.tzname(dt)

参数说明：

dt：表示datetime实例对象。
返回值：返回在构造timezone实例时指定的name值。如果没有为构造器提供name参数，则tzname(dt) 所返回的名称将根据offset 值按UTC+00:00 规则生成；如果offset 为timedelta(0)，则名称为“UTC”，否则为字符串’UTC±HH:MM’，其中±为offset 值的正负，HH 和MM 分别表示offset.hours 和offset.minutes。

使用tzname() 方法获取在构造timezone 实例时指定的name 值，代码如下：

import datetime                                           		# 导入datetime模块

# 创建名称为欧洲 马德里时区

timezone_madrid = datetime.timezone(datetime.timedelta(hours=2),name=’Europe/Madrid’)

reduce_four = datetime.timezone(datetime.timedelta(hours=-4))  	# 创建-4时区对象

plus_four = datetime.timezone(datetime.timedelta(hours=4))    	# 创建+4时区对象

utc_time = datetime.timezone(datetime.timedelta(hours=0))     	# 创建UTC时区对象，协调世界时为0

dt = datetime.datetime.now()                               		# datetime对象

print(timezone_madrid.tzname(dt))                           	# 打印时区名称

print(reduce_four.tzname(dt))                              		# 打印-4时区

print(plus_four.tzname(dt))                                		# 打印+4时区

print(utc_time.tzname(dt))                                 		# 打印UTC时区

65. utcoffset()方法——返回指定的 UTC偏移量

timezone 类中的utcoffset() 方法用于获取在构造timezone 实例时指定的UTC 偏移量。语法格式如下：

timezone对象名.utcoffset(dt)

参数说明：

dt ：表示datetime实例对象。
返回值：返回在构造timezone实例时指定的UTC偏移量。

使用utcoffset() 方法获取在构造timezone 实例时指定的UTC 偏移量，代码如下：

import datetime                                           		# 导入datetime模块

# 创建名称为欧洲 马德里时区

timezone_madrid = datetime.timezone(datetime.timedelta(hours=2),name=’Europe/Madrid’)

reduce_four = datetime.timezone(datetime.timedelta(hours=-4))  	# 创建-4时区对象

plus_four = datetime.timezone(datetime.timedelta(hours=4))    	# 创建+4时区对象

utc_time = datetime.timezone(datetime.timedelta(hours=0))     	# 创建UTC时区对象，协调世界时为0

dt = datetime.datetime.now()                               		# datetime对象

print(timezone_madrid.utcoffset(dt))                        	# 打印时区名称

print(reduce_four.utcoffset(dt))                            	# 打印-4时区

print(plus_four.utcoffset(dt))                             		# 打印+4时区

print(utc_time.utcoffset(dt))                              		# 打印UTC时区