第七章 datetime模块

已于 2023-06-19 23:17:35 修改
阅读量1.2k 收藏 14
点赞数
分类专栏： Python 笔记（常用模块） 文章标签： python 算法
于 2023-06-19 23:11:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42226855/article/details/131142972
版权

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())          		# 打印当前日期中星期对应的数字

程序运行结果如下：

3

使用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时区
Zhao.Mr
关注
  • 0
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
python datetime模块安装_Python datetime模块
weixin_39611722的博客
12-03 8263
一、简介在 python 中，datetime 是对日期数据进行处理的主要模块。无论何时你需要用 python 处理日期数据，datetime 都能提供所需方法。datetime 是 python 标准库的一部分，这意味着你无须单独安装它。你可以用如下语句直接导入：import datetimedatetime 模块共有以下类：datetime类date 类time 类timedelta 类二、获...
python导入datetime模块_Python第十一章-常用的核心模块04-datetime模块
weixin_39540725的博客
02-03 542
python 自称 "Batteries included"(自带电池, 自备干粮?), 就是因为他提供了很多内置的模块, 使用这些模块无需安装和配置即可使用.本章主要介绍 python 的一些内置常用核心模块Python 常用的核心模块四、datetime模块datetime模块是专门用来处理时间的标准库模块.模块名是datetime, 这个模块的内部定义多个类.datetime模块下有个类da...
datetime模块详解
acktomas的博客
06-05 708
类的合体，其大部分的方法和属性都继承于这二个类，相关的操作方法请参阅，本文上面关于二个类的介绍。可以计算: 天(days), 小时(hours), 分钟(minutes), 秒(seconds), 微秒(microseconds).差值不只是可以查看相差多少秒，还可以查看天(days), 秒(seconds), 微秒(microseconds).对完整格式代码集的支持在不同平台上有所差异，因为 Python 要调用所在平台的 C 库的。函数，而不同平台的差异是很常见的。： 返回公元公历开始到现在的天数。
Python3中常用模块-datetime模块
ixusy88的博客
06-01 1104
datetime模块提供了处理日期和时间的类，既有简单的方式，又有复杂的方式。它虽然支持日期和时间算法，但其实现的重点是为输出格式化和操作提供高效的属性提取功能。（可以理解为对time模块的进一步封装，里面的时间获取，转换还是使用time模块中的函数） 1：获取模块帮助文档 import datetime print(datetime.__doc__) print(dir(datetime)) for item in dir(datetime): print(item) print(h
python datetime模块
weixin_49346755的博客
06-13 2526
datetime模块为python标准库的一个模块，该模块提供了对时间和日期进行操作的功能。datatime模块通过date类、time类、datetime类、timedelta类、timezone类等来获取或者操作时间、日期。在python中，有三个标准模块可以对时间和日期进行操作，分别是time模块、datetime模块、calendar模块。其中time模块是通过调用C库实现的，所以有些方法在某些平台上可能无法调用，但是其提供的大部分接口与C标准库time.h基本一致。与time模块相比，dateti
Python-datetime模块详解（未完，待续）
厚积而薄发
03-10 1125
文章目录一、datetime模块介绍1.datetime包含的类2.datetime包含的常量二、date类1.对象构成2、date对象中包含的方法与属性1、用于日期比较大小的方法2、获得二个日期相差多少天3、ISO标准化日期4、其他方法与属性 一、datetime模块介绍 1.datetime包含的类 2.datetime包含的常量 二、date类 1.对象构成 获取当天的年月日 >>> from datetime import date >>> today =
python模块datetime_Python模块-datetime
weixin_42303107的博客
02-21 131
datetime模块定义了下面这几个类：datetime.date：表示日期的类。常用的属性有year, month, day；datetime.time：表示时间的类。常用的属性有hour, minute, second, microsecond；datetime.datetime：表示日期时间。datetime.timedelta：表示时间间隔，即两个时间点之间的长度。datetime.tzi...
python的datetime模块需要装吗_Python下time模块和datetime模块的使用
weixin_39796839的博客
02-21 158
time模块时间表示格式:1.格式化时间: 【 2018-01-01 01:00:00 】2.时间戳: 【 1518407077.940927 】 -> 秒数(从1970开始到现今)3.以元组方式表示，九个元素(格式化元组)元素如下:(1) tm_year=2018, # 年(2) tm_mon=2, # 月(3) tm_mday=12, # 日(4) tm_hou...
【Python基础】datetime模块
kingwsq的专栏
08-13 3732
整理了Python中datetime模块的常见用法
Python时间模块之datetime模块
热门推荐
json_li的博客
12-12 1万+
在项目开发中做功能经常会用到关于时间的操作。比如会员过期的定时任务，一些代码的延迟执行。time、calendar、datetime模块。今天介绍的是datetime模块。在python中表示时间的格式有三种：时间戳、元组、格式化时间。与time模块类似，datetime模块也能够将datetime类型转换成这三种类型。
Python中datetime模块参考手册
09-21
Python中的datetime模块是用于处理日期和时间的核心模块，它提供了丰富的功能来创建、操作和格式化日期和时间。在Python中，处理日期和时间通常涉及datetime、time和calendar这三个模块，但datetime模块是最常用的一...
以 Python 的 datetime 模块为例
02-02
Python 的 datetime 模块是处理日期和时间的重要工具，它为程序员提供了丰富的功能，包括日期的计算、时间的格式化以及与时间戳的转换等。在这个主题中，我们将深入探讨 datetime 模块的核心概念和常见用法。 1. **...
Python中time模块和datetime模块的用法示例
12-24
time模块方法： time.time():获取当前时间的时间戳 time.localtime():接受一个时间戳，并把它转化为一个当前时间的元组。不给参数的话就会默认将time.time()作为参数传入 time.localtime(): 索引 属性 含义 ...
第6章 函数.pptx
05-21
### 第6章 函数 #### 一、什么是函数？ 在编程中，函数是一段被封装起来的代码，它可以实现特定的功能并且可以被多次调用。使用函数的主要目的是提高代码的复用性和模块性，使程序结构更加清晰。例如，在一个程序...
Python中datetime常用时间处理方法
09-21
此外，`datetime`模块还提供了获取本周和本月第一天的日期的函数。下面的代码展示了如何实现这一功能： ```python def first_day_of_month(): return datetime.date.today() - datetime.timedelta(days=datetime....
快醒醒，别睡了!...讲《数据分析pandas库》了—/—＜4＞
最新发布
qq_64603703的博客
07-27 960
详细解说数据分析pandas库中的常用方法
全网最详细Gradio教程系列5——Gradio Client: python
shao918516的博客
07-26 1057
程序部署完成后，如何将Gradio App作为API访问使用呢，这就用到Gradio Client。本章讲解Gradio Client的三种使用方式：python、javascript和curl，受字数限制，所以分三篇博客发布。 使用Gradio Python Client非常易于将Gradio应用程序作为API使用，本节讲述gradio_client安装、如何连接Gradio应用程序、查看可用API及其使用方式、job及session等用法。 通过Gradio Python Cli
全面解析 SnowNLP：中文文本处理、情感分析
有勇气的牛排博客
07-24 720
SnowNLP 是一个专门用于处理中文文本的 Python库。分词情感分析关键词提取文本分类拼音转换繁体转简体词相似度计算等测试环境：Python3.10.9尚未测出该功能text = "有勇气的牛排写的文章通俗易懂，爱了爱了"文本分类使用的是 SnowNLP 的情感分析模型。
python中datetime模块中isocalendar()函数的作用？
04-22
好的，我明白了。关于你的问题，datetime模块中的isocalendar()函数可以获取一个日期的ISO年份，ISO周数和ISO周中的星期几。返回值是一个元组，其中元组中的第一个元素是ISO年份，第二个元素是ISO周数，第三个元素是ISO周中的星期几。ISO周指的是符合国际标准化组织（ISO）规定的一年中的周数，其中第一周始于该年中的第一个周四，其他周从周一开始，以七天为周期。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值