第八章 time模块

1. time模块介绍

time 模块提供了各种时间相关的函数，该模块中对于时间表示的格式有如下三种：

• 时间戳（timestamp）：时间戳表示的是从1970 年1 月1 日00:00:00 开始按秒计算的偏移量。

• 时间元组（struct_time）：共有九个元素，分别为：年、月、日、时、分、秒、一周中的第几日、一年中的第几日、夏令时。

• 格式化时间字符串（format time）：已格式化的结构使时间更具可读性，包括自定义格式和固定格式。

2. 时间戳

时间戳（timestamp）表示的是从1970 年1 月1 日00:00:00 开始按秒计算的偏移量，也就是指格林尼治时间1970 年01 月01 日00 时00 分00 秒（即北京时间1970 年01 月01 日08 时00 分00 秒）起至现在的总秒数，它返回的是float 类型。但是在1970 年之前的日期就无法用时间戳来表示，太遥远的日期也无法用时间戳表示，且UNIX 和Windows 只支持到2038 年。

导入time 模块，然后通过time 模块调用time() 方法获取当前时间的时间戳，代码如下：

import time        			# 导入time模块

print(time.time())  		# 获取当前时间的时间戳

3. 时间元组

在Python 中，使用9 个元素组成的元组来处理时间，我们称之为时间元组（struct_time 元组）。时间元组中9 个元素分别为：年、月、日、时、分、秒、一周中的第几日、一年中的第几日、夏令时。struct_time 元组的含义及属性如表1 所示。

导入time 模块，然后通过time 模块调用localtime() 方法获取当地时间的时间元组，代码如下：

import time            		# 导入time模块

print(time.localtime())  	# 接收时间戳并返回当地时间的时间元组

程序运行结果如下：

time.struct_time(tm_year=2020, tm_mon=3, tm_mday=11, tm_hour=8, tm_min=54, tm_sec=53,tm_wday=2, tm_yday=71, tm_isdst=0)

说明：当前时间为：2020 年，3 月，11 日，8 时，54 分，53 秒，星期三，一年中的第71 天，不是夏令时。

4. 格式化的时间字符串

常用的时间日期格式化符号：

完整英文星期名称和简写英文星期名称：

完整英文月份名称和简写英文月份名称:

导入time 模块，然后调用time 模块的strftime() 方法按“年- 月- 日 时: 分: 秒”格式输出日期时间，代码如下：

import time                             		# 导入time模块

print(time.strftime(‘%Y-%m-%d %H:%M:%S’))   	# 打印年-月-日 时:分:秒

5. altzone常量——获取夏令时时区的偏移量（秒为单位）

altzone 常量用于获取本地夏令时的偏移秒数，如果该地区在UTC 东部会返回负值（如西欧，包括英国），且对夏令时启用的地区才可以使用。语法格式如下：

time.altzone

参数说明：

• 返回值：返回本地夏令时的偏移秒数。

调用altzone 常量获取本地夏令时的偏移秒数，代码如下：

import time        	# 导入time模块

print(‘本地夏令时的偏移秒数为：',time.altzone)

6. daylight常量——获取是否定义了夏令时

daylight 常量用于获取是否定义了夏令时时区。语法格式如下：

time.daylight

参数说明：

• 返回值：如果定义了夏令时的时区将返回1；否则返回0。

调用daylight 常量获取当前系统时区是否定义了夏令时，代码如下：

import time        	# 导入time模块

print(‘确认定义夏令时时区的返回值为:’,time.daylight)

7. timezone常量——获取非夏令时时区的偏移量（秒为单位）

timezone 常量用于获取本地非夏令时的偏移秒数（西欧大部分地区与亚洲为负，美国为正，英国为零），且对非夏令时的地区才可以使用。语法格式如下：

time.timezone

参数说明：

• 返回值：返回非夏令时时区的偏移秒数。

调用timezone 常量获取北京非夏令时时区的偏移量，代码如下：

import time    	# 导入time模块

print(‘北京非夏令时时区的偏移量为：',time.timezone,’秒')

8. tzname常量——返回标准时区名称与夏令时时区名称所组成的元组

tzname 常量用于获取包含两个字符串的元组，该元组中的第一个值为本地非夏令时时区名称，第二个值为本地夏令时时区名称。语法格式如下：

time.tzname

参数说明：

• 返回值：返回标准时区名称与夏令时时区名称所组成的元组。

使用tzname 常量，由于返回的元组信息为乱码，所以需要进行编码后输出，代码如下：

import time           		# 导入time模块

tz=time.tzname         		# 获取计算机当前标准时区与夏令时时区名称

print(‘返回的元组信息为：',tz)


# 由于返回的元组信息为乱码，所以需要进行编码后输出

print(‘标准时区名称为：',tz[0].encode(‘latin-1’).decode(‘gbk’))

print(‘夏令时时区名称为：',tz[1].encode(‘latin-1’).decode(‘gbk’))

9. asctime()方法——接收时间元组并返回一个字符串

asctime() 方法用于接收时间元组，并返回一个可读长度为24 个字符的字符串，语法格式如下：

time.asctime([t]))

参数说明：

• t ：表示完整的9 位元素元组或者通过方法localtime() 方法或gmtime() 方法返回的时间值。参数为空时，默认以time.localtime() 的值为参数，所得到的是当前时间。

• 返回值：返回一个字符串，格式为：Www Mmm dd hh:mm:ss yyyy。其中Www为星期、Mmm为月份、dd 为日、hh 为时、mm 为分、ss 为秒、yyyy 为年份。

使用asctime() 方法输出时间元组对应的时间字符串，代码如下：

import time                                       				# 导入time模块

t = (2018,12,13,21,36,54,3,347,0)                    			# 创建一个名称为t的时间元组

print(‘指定时间元组： ‘,time.asctime(t))               			# 指定时间元组

print(‘默认时间元组： ‘,time.asctime())                			# 参数为空

print(‘UTC时区的时间元组：',time.asctime(time.gmtime())) 		# 设置参数为time.gmtime()

10. clock()方法——以浮点数返回当前的CPU时间

clock() 方法用于获取浮点类型的当前CPU 时间，可以用来衡量不同程序的运行时间。语法格式如下：

time.clock()

参数说明：

• 返回值：第一次调用该方法，返回的时间为本次程序开始执行到调用clock() 方法结束所经过的秒数；第二次调用该方法，返回的时间为本次程序开始执行到第二次调用结束所经过的秒数，其类型为浮点型。

说明:time.clock() 方法在Python 3.3 中已被弃用，将从Python 3.8 中删除，但可以使用time.perf_counter()方法或time.process_time() 方法来代替。

time() 方法与clock() 方法都可以返回一个时间信息，不同的是，time() 方法返回格林尼治时间1970 年01 月01 日00 时00 分00 秒（北京时间1970 年01 月01 日08 时00 分00 秒）起至现在的总秒数；而clock() 方法返回自程序执行开始到clock() 方法结束所经过的秒数，代码如下：

import time        # 导入time模块

print(‘time方法的执行结果为：',time.time())

print(‘clock方法的执行结果为：',time.clock())

程序运行结果如下：

time方法的执行结果为：1564470063.4872446

clock方法的执行结果为：0.0679539

说明:由于time.clock() 方法已被弃用，所以在运行结果中会出现如下警告信息：

C:/Users/Administrator/Desktop/test1/t.py:13: DeprecationWarning: time.clock has beendeprecated in Python 3.3 and will be removed from Python 3.8: use time.perf_counter or time.process_time instead

print(‘clock方法的执行结果为：',time.clock())

11. ctime()方法——接收时间戳并返回一个字符串

ctime() 方法用于以时间戳为参数，返回一个字符串。语法格式如下：

time.ctime([secs])

参数说明：

• secs：要转换为字符串时间的秒数。如果没有参数或参数为None，将默认以time.time() 方法的时间戳作为参数，此时，ctime() 方法的的作用相当于asctime(localtime(secs)) 方法。

• 返回值：返回一个字符串。

分别使用ctime() 方法和asctime() 方法输出本地时间戳对应的时间字符串，代码如下：

import time           	# 导入time模块

print(time.ctime())    	# 使用ctime()方法输出表示本地时间的字符串

print(time.asctime())   # 使用asctime()方法输出表示本地时间的字符串

程序运行结果如下：

Wed Mar 11 09:03:15 2020

Wed Mar 11 09:03:15 2020

使用ctime() 方法以指定的时间戳为参数返回对应的时间字符串，代码如下：

import time                         		# 导入time模块

print(time.ctime(1589383417.9643884 )) 		# 打印指定时间戳对应的字符串

12. get_clock_info()方法——获取指定时钟以命名空间对象形式的信息

get_clock_info() 方法用于获取指定时钟以命名空间对象形式的信息。语法格式如下：

time.get_clock_info(name)

参数说明：

• name：该参数为需要获取的指定时钟方法的名称，其类型为字符类型。如获取time() 方法对应的命名空间对象信息时，只需填写字符型名称‘time’ 即可。

• 返回值：返回指定时钟以命名空间对象形式的信息。

使用get_clock_info() 方法获取time() 方法的时钟信息，代码如下：

import time 									# 导入time模块

time_namespace = time.get_clock_info(‘time’) 	# 获取time()方法的时钟信息

print(time_namespace)

程序运行结果如下：

namespace(adjustable=True, implementation='GetSystemTimeAsFileTime()', monotonic=False,

resolution=0.015625)

说明:在返回的时钟信息中具有以下四个特性：
adjustable ：如果时钟可以自动更改（例如通过NTP 守护程序）或由系统管理员手动更改，则为True ；否则为False。
implementation ：用于获取时钟值的底层C函数的名称。关于可能的值，请参考时钟ID 常量。
monotonic ：如果时钟不能倒退，则为True ；否则为False。
resolution ：以秒为单位的时钟分辨率（float）。

将常见的时钟方法名称添加至列表中，然后通过for 循环获取每个时钟方法对应的信息，代码如下：

import time                                       		# 导入time模块

# 常见时钟方法名称

time_list = [‘time’,’thread_time’,’process_time’,’perf_counter’,’monotonic’]

for i in time_list:                                		# 循环遍历每个时钟方法对应的名称

print(i,’方法的时钟信息为：\n’,time.get_clock_info(i))   	# 打印每个时钟方法的信息

13. gmtime()方法——接收时间戳并返回UTC时区的时间元组

gmtime() 方法用于将一个时间戳转换为UTC 时区（0 时区）的时间元组，返回time.struct_time类型的对象。语法格式如下：

time.gmtime([secs])

参数说明：

• secs：转换为time.struct_time类型的对象的秒数，其默认值为time.time()。

• 返回值：返回指定时间戳所对应UTC时区的时间元组。

首先使用localtime() 方法输出本地时间的时间元组，然后使用gmtime() 方法输出UTC 时区的时间元组，对比两种时间元组的不同，代码如下：

import time 		# 导入time模块

print(‘本地时间的时间元组为：', time.localtime())

print(‘UTC时区的时间元组为： ‘, time.gmtime())

程序运行结果如下：

本地时间的时间元组为： time.struct_time(tm_year=2020, tm_mon=3, tm_mday=11, tm_hour=9, tm_min=8, tm_sec=4, tm_wday=2, tm_yday=71, tm_isdst=0)

UTC时区的时间元组为： time.struct_time(tm_year=2020, tm_mon=3, tm_mday=11, tm_hour=1,tm_min=8, tm_sec=4, tm_wday=2, tm_yday=71, tm_isdst=0)

说明:UTC（Coordinated Universal Time）是世界协调时间（又称世界标准时间、世界统一时间），世界协调时间以原子时秒长为基础，在时刻上尽量接近于世界时的一种时间计量系统。gmtime() 方法和localtime() 方法类似，都能返回时间元组。localtime() 方法返回的是当前时区的时间元组，而gmtime() 方法返回的是UTC 时区（0 时区）的时间元组。与UTC 时间对应的就是各个时区的本地时间，东N区的时间比UTC时间早N个小时，因此，UTC时间+ N 小时即为东N区的本地时间；而西N 区时间比UTC 时间晚N 个小时，因此，UTC 时间- N 小时即为西N 区的本地时间。中国在东8 区，因此比UTC 时间早8 小时，可以以UTC+8 表示。

14. localtime()方法——接收时间戳并返回本地时间的时间元组

localtime() 方法用于将时间戳转换为本地时间的时间元组。语法格式如下：

time.localtime([secs])

参数说明：

• secs：转换为time.struct_time类型的对象的秒数。如果secs参数未提供或为None，则返回当前时间（即默认调用time.time()）。

• 返回值：返回指定时间戳对应的本地时间的时间元组。

使用localtime() 方法获取本地当前时间的时间元组，代码如下：

import time 								# 导入time模块

print(time.localtime()) 					# 打印本地当前时间的时间元组

print(time.localtime(time.time()))			# 以time.time()返回的时间戳为参数获取本地时间的时间元组

程序运行结果如下：

time.struct_time(tm_year=2020, tm_mon=3, tm_mday=11, tm_hour=9, tm_min=9, tm_sec=7, tm_wday=2, tm_yday=71, tm_isdst=0)

time.struct_time(tm_year=2020, tm_mon=3, tm_mday=11, tm_hour=9, tm_min=9, tm_sec=7, tm_wday=2, tm_yday=71, tm_isdst=0)

使用localtime() 方法将给定的时间戳转换为时间元组，代码如下：

import time                            			# 导入time模块

print(time.localtime(1584773763.789422))  		# 将给定的时间戳转换为当地时间的时间元组

程序运行结果如下：

time.struct_time(tm_year=2020, tm_mon=3, tm_mday=21, tm_hour=14, tm_min=56, tm_sec=3,tm_wday=5, tm_yday=81, tm_isdst=0)

在获取时间元组的属性时，可以通过“. 属性名”的方式来获取对应的值，也可以通过下标索引来获取对应的属性值，代码如下：

import time                             			# 导入time模块

t = time.localtime()                     			# localtime()方法获取本地当前时间的时间元组

print(‘本地当前时间的时间元组为：',t)        			# 打印本地当前时间的时间元组

print(‘属性名获取的年份为：',t.tm_year, “年")  		# 通过“.属性名”的方式获取年份

print(‘下标索引获取的月份为：',t[1], “月")     		# 通过下标索引获取月份

15. mktime()方法——接收时间元组并返回时间戳

mktime() 方法用于以时间元组作为参数并返回时间戳。语法格式如下：

time.mktime(t)

参数说明：

• t：结构化的时间或者完整的9 位元素元组。

• 返回值：返回用秒数来表示时间的浮点数。

使用mktime() 方法获取指定的时间元组为参数返回的时间戳，代码如下：

import time                      	# 导入time模块

t=(2018,12,13,21,36,54,3,347,0)    	# 创建一个名称为t的时间元组

print(time.mktime(t))            	# 以时间元组作为参数并返回时间戳

程序运行结果如下：

1544708214.0

说明:如果传入的值不是一个合法的时间元组，将触发OverflowError 或ValueError 错误异常。

首先使用localtime() 方法获取本地当前时间的时间元组，然后将获取的时间元组作为mktime()方法的参数并输出返回的时间戳，代码如下：

import time                         		# 导入time模块

t=time.localtime()                   		# 获取本地当前时间的时间元组

print(‘本地当前时间的时间元组为：',t)     	# 输出本地当前时间的时间元组

print(‘返回的时间戳为：',time.mktime(t))  	# 以本地当前时间的时间元组为参数返回时间戳

16. monotonic()方法——获取单调时钟的值

monotonic() 方法用于获取一个单调时钟的值（以浮点类型的秒为单位）。该值为不能倒退的时钟值，并且该值不会受到系统时钟更新后的影响。语法格式如下：

time.monotonic()

参数说明：

• 返回值：返回一个单调时钟的值。

由于单调时钟的值不能倒退，所以计算两次调用之间的差值即可获取代码的休眠时间，代码如下：

import time                      	# 导入time模块

start_time = time.monotonic()      	# 第一次调用

time.sleep(2)                    	# 休眠2秒

end_time = time.monotonic()        	# 第二次调用

print(‘第一次返回的单调时钟值为：',start_time)

print(‘第二次返回的单调时钟值为：',end_time)

print(‘计算的休眠时间为：',end_time-start_time)

17. monotonic_ns()方法——获取单调时钟的（纳秒）值

monotonic_ns() 方法用于获取一个单调时钟的值（以浮点类型的纳秒为单位）。该值为不能倒退的时钟值，并且该值不会受到系统时钟更新的影响。语法格式如下：

time.monotonic_ns()

参数说明：

• 返回值：返回一个单调时钟的（纳秒）值。

通过计算两次调用之间的差值来获取代码休眠的纳秒时间，代码如下：

import time                      		# 导入time模块

start_time = time.monotonic_ns()   		# 第一次调用

time.sleep(2)                    		# 休眠2秒

end_time = time.monotonic_ns()     		# 第二次调用

print(‘第一次返回的单调时钟纳秒值为：',start_time)

print(‘第二次返回的单调时钟纳秒值为：',end_time)

print(‘计算休眠时间的纳秒为：',end_time-start_time)

18. perf_counter()方法——获取性能计数器的（秒）值

perf_counter() 方法用于获取一个性能计数器的（秒）值，包含整个系统的睡眠时间。由于返回值的基准点是未定义的，所以只有连续调用的结果之间的差才是有效的。语法格式如下：

time.perf_counter()

参数说明：

• 返回值：返回一个性能计数器的（秒）值。

调用循环函数，通过perf_counter() 方法获取循环函数的运行时间（秒）值，代码如下：

import time                                              			# 导入time模块

def procedure():                                          			# 定义函数

a = 0                                                   			# 定义变量

for i in range(1000000):                                  			# 循环

a+=i                                                				# 循环增加变量

print(a)                                             				# 打印当前变量值

start_time = time.perf_counter()                            		# 第一次调用perf_counter()方法

procedure()                                              			# 调用循环增加变量的函数

print(‘函数的运行时间为：',time.perf_counter()-start_time,’秒')   	# 打印函数运行的时间

19. perf_counter_ns()方法——获取性能计数器的（纳秒）值

perf_counter_ns() 方法用于获取一个性能计数器的（纳秒）值，包含整个系统的睡眠时间。由于返回值的基准点是未定义的，所以只有连续调用的结果之间的差才是有效的。语法格式如下：

time.perf_counter_ns()

参数说明：

• 返回值：返回一个性能计数器的（纳秒）值。

调用循环函数，通过perf_counter_ns() 方法获取循环函数运行时间的（纳秒）值，代码如下：

import time                                                  			# 导入time模块

def procedure():                                             			# 定义函数

a = 0                                                      				# 定义变量

for i in range(1000000):                                     			# 循环

a+=i                                                    				# 循环增加变量

print(a)                                                				# 打印当前变量值

start_time = time.perf_counter_ns()                            			# 第一次调用perf_counter_ns()方法

procedure()                                                  			# 调用循环增加变量的函数

print(‘函数的运行时间为：',time.perf_counter_ns()-start_time,’纳秒')  	# 打印函数运行的时间

20. sleep()方法——按指定的秒数使程序休眠若干时间

sleep() 方法的作用是休眠，使程序按指定的秒数休眠若干时间。语法格式如下：

time.sleep(secs)

参数说明：

• secs：休眠执行的秒数。secs 以秒为单位，如果想定时毫秒，可以使用小数，以便指示更精确地暂停时间。如0.1 秒，则代表暂停100 毫秒。

• 返回值：无。

使用sleep() 方法实现延迟5 秒，然后通过print() 函数输出文本内容，代码如下：

import time        	# 导入time模块

time.sleep(5)      	# 延迟5秒

print(‘人生苦短，我用Python！')

程序运行结果如下：

人生苦短，我用Python！

使用sleep() 方法与ctime() 方法实现输出休眠前与休眠后的本地时间所对应的字符串，代码如下：

import time           	# 导入time模块

print(time.ctime())    	# 输出表示本地时间的字符串

time.sleep(10)         	# 休眠10秒

print(time.ctime())    	# 休眠10后输出表示本地时间的字符串

21. strftime()方法——把日期格式转为字符串格式

strftime() 方法用于格式化日期，把日期格式转换为字符串格式。该方法可以接收时间元组或者struct_time（如由localtime() 或gmtime() 返回的），按照指定格式转换为字符串格式，格式由参数format 决定。语法格式如下：

time.strftime(format[,t])

参数说明：

• format ：时间字符串所对应的格式，格式符号参考表2。

• t ：可选参数，一个struct_time对象。如果没有提供t，则使用localtime()返回的当前时间。

• 返回值：返回以可读字符串表示的时间。

使用strftime() 方法输出不同格式的年、月、日，代码如下：

import time                   		# 导入time模块

print(time.strftime(‘%Y,%m,%d’)) 	# 输出年,月,日

print(time.strftime(‘%Y/%m/%d’)) 	# 输出年/月/日

print(time.strftime(‘%Y-%m-%d’)) 	# 输出年-月-日

程序运行结果如下：

2020,03,11

2020/03/11

2020-03-11

使用strftime() 方法格式化输出日期、时间、星期及月份，代码如下：

import time                                			# 导入time模块

print(time.strftime(‘%Y-%m-%d %H:%M:%S %A %B’)) 	# %A输出英文星期全称，%B输出英文月份全称

print(time.strftime(‘%Y-%m-%d %H:%M:%S %a %b’)) 	# %a输出英文星期简称，%b输出英文月份简称

程序运行结果如下：

2020-03-11 09:17:09 Wednesday March

2020-03-11 09:17:09 Wed Mar

使用strftime() 方法格式化多种时间对象，代码如下：

import time                   			# 导入time模块

t=(2020,12,13,21,36,54,3,347,0) 		# 创建一个名称为t的时间元组

# 根据提供的时间元组获取年-月-日 时:分:秒

print(time.strftime(‘%Y-%m-%d %H:%M:%S’,t))

# 根据localtime()返回的时间获取年 月 日 时 分 秒

print(time.strftime(‘%Y %m %d %H %M %S’,time.localtime()))

# 根据gmtime()返回的时间获取年,月,日 时:分:秒

print(time.strftime(‘%Y,%m,%d %H:%M:%S’,time.gmtime()))

22. strptime()方法——把时间字符串转为时间元组

strptime() 方法用于根据指定的格式把一个时间字符串转为时间元组，语法格式如下：

time.strptime(string[,format])

参数说明：

• string：表示时间字符串。

• format ：表示时间字符串所对应的格式，格式符号参考表2。

• 返回值：返回struct_time对象。

使用strptime() 方法将指定的时间字符串转换为时间元组，代码如下：

import time                                              			# 导入time模块

print(time.strptime(“2020-07-29 21:36:54”,”%Y-%m-%d %H:%M:%S”)) 	# 将时间字符串转为时间元组

23. time()方法——返回当前时间的时间戳

time 模块中的time() 方法用于返回当前时间的时间戳。语法格式如下：

time.time()

参数说明：

• 返回值：返回当前时间的时间戳。

使用time() 方法获取当前时间戳的显示范围，代码如下：

import time                                    			# 导入time模块

print(‘取整后的时间戳为： ‘,int(time.time()))       		# 对时间戳取整

print(‘小数点后两位的时间戳为：',’%.2f’ % time.time())  	# 打印小数点后两位的时间戳

程序运行结果如下：

取整后的时间戳为： 1564127484

小数点后两位的时间戳为： 1564127484.35

首先使用time() 方法获取当前时间戳，由于秒与毫秒之间的换算单位为1000，所以需要用当前的时间戳*1000，才可获取时间戳的毫秒数；再通过int() 与round() 函数对时间戳的毫秒数进行四舍五入并取整，代码如下：

import time                                		# 导入time模块

millis = time.time() * 1000                  	# 获取时间戳毫秒数

millis_int = int(round(time.time() * 1000))    	# 四舍五入并取整

print(‘时间戳的毫秒为：',millis)

print(‘四舍五入取整后：',millis_int)

24. time_ns()方法——返回当前时间的 时间戳（纳秒）

time 模块中的time_ns() 方法与time() 方法类似，用于返回以纳秒为单位的时间戳。语法格式如下：

time.time_ns()

参数说明：

• 返回值：返回以纳秒为单位的时间戳。

使用time_ns() 方法获取当前时间戳的纳秒值，代码如下：

import time    		# 导入time模块

print(‘当前时间戳的纳秒值为：', time.time_ns())