Python基础学习之时间模块 time模块 datetime模块

Python中，关于时间的模块，常用为：time & datetime 两个模块； 时间相关的模块虽然内容挺多，但是并不需要死记硬背，只要留个印象就好；因为实际编程中，对时间的使用相对固定，主要为以下场景：

计算程序的运行时间；

时间类型转换；系统生成的log中的时间字符串，变化成需要的格式化字符串格式；

时间的运算；

固定时间运行程序； 以上的场景，在实例中给出，参考 5.0 实例；我觉得只要 5.0 的三个例子可以掌握，就基本够用了；

1. time 模块

1.1 time 模块_时间转换的关系图

备注：可视化时间其实就是格式化字符串；

1.2 时间转换方法详解

1.2.1 引入time 模块

# 引入time 模块 import time

1.2.2 获取时间戳

# 当前时间戳 time.time() # 输出：1600853751.2822378

1.2.3 当前时间元组

# 当前时间元组 time.localtime() # 输出: time.struct_time(tm_year=2020, tm_mon=9, tm_mday=23, tm_hour=17, tm_min=37, tm_sec=22, tm_wday=2, tm_yday=267, tm_isdst=0) # 实际上时间元组是：(2020,9,23,17,37,22,2,267,0) # 时间元组（年、月、日、时、分、秒、一周的第几日、一年的第几日、夏令时） # 一周的第几日: 0-6 # 一年的第几日: 1-366 # 夏令时: -1, 0, 1

1.2.4 时间戳 ==> 时间元组；localtime() & gmtime()

# 时间戳 ==> 时间元组 time.localtime(1600853751.2822378) # 传入时间戳，输出对应的时间元组； # time.struct_time(tm_year=2020, tm_mon=9, tm_mday=23, tm_hour=17, tm_min=35, tm_sec=51, tm_wday=2, tm_yday=267, tm_isdst=0) time.gmtime(1600853751.2822378) # 返回的时间为格林威治时间，即比我们的时间早 8 小时 # time.struct_time(tm_year=2020, tm_mon=9, tm_mday=23, tm_hour=9, tm_min=35, tm_sec=51, tm_wday=2, tm_yday=267, tm_isdst=0)

1.2.5 时间戳 ==> 可视化时间；ctime()

# 时间戳 ==> 可视化时间 time.ctime() # 输出：Wed Sep 23 17:41:32 2020 time.ctime(1600853751.2822378) # 传入时间戳，输出：Wed Sep 23 17:35:51 2020

1.2.6 时间元组 ==> 时间戳；mktime()

# 时间元组 ==> 时间戳 time.mktime(time.localtime()) # 输出：1600853842.0 time.mktime((2020,9,23,17,37,22,2,267,0)) # 输出：1600855090.0

1.2.7 时间元组 ==> 可视化时间（默认格式）；asctime()

# 时间元组 ==> 可视化时间 time.asctime() # 输出：Wed Sep 23 17:50:56 2020 time.asctime(time.localtime()) # 输出：Wed Sep 23 17:52:55 2020 time.asctime((2020,9,23,17,37,22,2,267,0)) # 输出：Wed Sep 23 17:37:22 2020

1.2.8 时间元组 ==> 可视化时间（自定义格式）；strftime()

# 时间元组 ==> 可视化时间(定制) time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()) # 输出：2020-09-23 18:09:00 time.strftime("%Y-%m-%d %H:%M:%S", (2020,9,23,17,37,22,2,267,0)) # 输出：2020-09-23 17:37:22

自定义格式时的代表字符，这里的内容，在时间模块中通用，想要自定义时间的输出格式，就需要用到以下内容：

''' %y 两位数的年份表示（00-99） %Y 四位数的年份表示（000-9999） %m 月份（01-12） %d 月内中的一天（0-31） %H 24小时制小时数（0-23） %I 12小时制小时数（01-12） %M 分钟数（00=59） %S 秒（00-59） %a 本地简化星期名称 %A 本地完整星期名称 %b 本地简化的月份名称 %B 本地完整的月份名称 %c 本地相应的日期表示和时间表示 %j 年内的一天（001-366） %p 本地A.M.或P.M.的等价符 %U 一年中的星期数（00-53）星期天为星期的开始 %w 星期（0-6），星期天为星期的开始 %W 一年中的星期数（00-53）星期一为星期的开始 %x 本地相应的日期表示 %X 本地相应的时间表示 %Z 当前时区的名称 %% %号本身 '''

1.2.9 可视化时间（定制） ==> 时间元组

# 可视化时间（定制） ==> 时间元组 time.strptime(时间字符串，时间格式) time.strptime('2020-09-23 17:37:22', '%Y-%m-%d %H:%M:%S') # 输出：time.struct_time(tm_year=2020, tm_mon=9, tm_mday=23, tm_hour=17, tm_min=37, tm_sec=22, tm_wday=2, tm_yday=267, tm_isdst=-1)

1.3 时区 (time.tzname) & 延时函数 (time.sleep)

1.3.1 time.tzname 返回当地的时区名称和夏令时；

[bytes([ord(c) for c in s]).decode('gbk') for s in time.tzname] # 输出：['中国标准时间', '中国夏令时']

1.3.2 time.sleep(secs) 推迟调用线程的运行，secs指秒数

a = time.time() time.sleep(5) b=time.time() print(b-a) # 5.000340700149536 五秒延时

2. datetime 模块

2.1 datetime 模块_时间转换的关系图

备注：

可视化时间其实就是格式化字符串；

详细的每个方法如何使用，参考下文；

2.2 datetime 对象类的方法

2.2.1 模块的导入；

# 方法一： # 本文章所用的是第一个方法； import datetime # 方法二： from datetime import datetime

2.2.2 当前日期 & 时间；now() & today()

# 返回本地时间的datetime 对象 datetime.datetime.now() # 输出：2020-09-23 19:48:42.222601 datetime.datetime.today() # 输出：2020-09-23 19:48:42.222602

2.2.3 格林威治日期 & 时间；utcnow()

# 返回格林威治时间 的 datetime 对象 datetime.datetime.utcnow() # 输出：2020-09-23 11:51:33.029317 比北京时间早8小时

2.2.4 时间戳 ==> datetime 对象 ；fromtimestamp(时间戳)

# 将时间戳 ==> datetime 对象，其中：时间戳通过time模块获得 time.time() datetime.datetime.fromtimestamp(1600853751) # 输出：2020-09-23 17:35:51

2.2.5 时间戳 ==> datetime 对象（格林威治时间）；utcfromtimestamp(时间戳)

# 将时间戳 ==> datetime 对象（格林威治时间） datetime.datetime.utcfromtimestamp(1600853751) # 输出：2020-09-23 09:35:51 比北京时间早8小时

2.2.6 返回一个datetime, 距离公元 0 年间隔指定天数； fromordinal(天数)

# 返回距离公元0年的时间，datetime.fromordinal(天数) datetime.datetime.fromordinal(20) # 输出：0001-01-20 00:00:00 表示距离0-0-0 20天的时间

2.2.7 日期 & 时间 拼接 combine(date,time)

# 拼接date 和 time 对象，返回一个datetime对象 date = datetime.datetime.today().date() time = datetime.datetime.today().time() newdatetime= datetime.datetime.combine(date,time) print(newdatetime) # 输出：2020-09-23 20:09:57.651732

2.2.8 字符串 ==> datetime对象； strptime(字符串)

# 将格式化字符串转化成datetime对象；看着输出没有变化，其实类型变成了datetime,可以使用对应的属性； datetime.datetime.strptime('2020-09-23 20:09:57','%Y-%m-%d %H:%M:%S') # 输出：2020-09-23 20:09:57 datetime.datetime.strptime('2020-09-23', '%Y-%m-%d') # 输出：2020-09-23 00:00:00 datetime.datetime.strptime('2020-09-23', '%Y-%m-%d').year # 输出： 2020

2.2.9 datetime对象 ==> 字符串； str()

a=datetime.datetime.strptime('2020-09-23', '%Y-%m-%d') print(a) # 输出：2020-09-23 00:00:00 print(type(a)) # 输出：<class 'datetime.datetime'> b = str(a) print(b) # 输出：2020-09-23 00:00:00 print(type(b)) # 输出：<class 'str'>

2.3 datatime 对象实例的方法

2.3.1 创建datetime 实例

# 创建datetime实例，常用的方法； datetime.datetime(2020, 9, 23, 15, 50, 6) # 输出：2020-09-23 15:50:06 datetime.datetime.today() # 输出：2020-09-23 19:48:42.222601

2.3.2 date() 方法 & time() 方法

# date() 方法 datetime.datetime.today().date() # 输出：2020-09-23 # time() 方法 datetime.datetime.today().time() # 输出：20:27:42.009573

2.3.3 datetime ==> 时间戳；timestamp()

# timestamp() 方法 ， 返回对应datetime的时间戳 datetime.datetime.today().timestamp() # 输出：1600864222.266731

2.3.4 datetime ==> 可视化时间（格式化字符串）；ctime()

# ctime() ，返回默认的字符串格式 datetime.datetime.today().ctime() # 输出：Wed Sep 23 20:37:26 2020

2.3.5 datetime ==> 可视化时间（自定义的格式化字符串）；strftime()

# strftime(), 返回格式化字符串，格式可以自己定义； datetime.datetime.today().strftime('%Y-%m-%d %H:%M:%S') # 输出：2020-09-23 20:39:07

2.3.6 星期几？ weekday() 方法 & isoweekday()

# weekday() 方法，返回星期， 星期一为 0，星期天为 6 datetime.datetime.today().weekday() # 输出：2 说明是星期三 # isoweekday()， 返回星期， 星期一为 1，星期天为 7 datetime.datetime.today().isoweekday() # 输出：3 说明是星期三

2.3.7 返回一个元组，包含：年，周，星期；isocalendar()

# isocalendar()，返回一个元组，包含：年，周，星期 datetime.datetime.today().isocalendar() # 输出：(2020, 39, 3)

2.3.8 返回公元0年到指定时间的天数；toordinal()

# toordinal()， 返回公元0年到指定时间的天数 datetime.datetime.today().toordinal() # 输出：737691

2.4 datatime 对象实例的属性

常用属性就是：年，月，日，时，分，秒，可以直接使用属性得到对应的值，举例如下：

# datetime 对象的属性 datetime.datetime.today().year # 输出：2020 datetime.datetime.today().month # 输出：9 datetime.datetime.today().day # 输出：23 datetime.datetime.today().hour # 输出：20 datetime.datetime.today().minute # 输出：45 datetime.datetime.today().second # 输出：10 datetime.datetime.today().microsecond # 输出：782152 import pytz sh = pytz.timezone('Asia/Shanghai') # 不指定，输出None datetime.datetime(2020,9,23,tzinfo=sh).tzinfo # 用处不大，输出：Asia/Shanghai

3. datetime 模块与 time 模块的区别

time 的时间范围：1970年 - 2038年，1970.1.1 00:00:00以秒计算的偏移量 datatime 的时间范围：0年 - 9999年

datetime 是 time 的高级封装，所以比time模块的功能强大一些；

在对时间要求不多的项目里，两个模块都可以满足需求；

4. 时间的运算

时间的运算常常使用两个方法：timedelta() & relativedelta()

4.1 timedelta()

该方法属于 datetime 模块，可以计算周，天，时，分，秒的运算，不能计算年和月。举例如下：

# 周，天，时，分，秒的运算，可以使用timedelta();这里的参数都可以是浮点型； a = datetime.timedelta(weeks=1) # 给 a 赋值，一周的时间 # days, seconds, microseconds, milliseconds, minutes, hours, weeks 以上的这些参数都可以，然后datetime类型的时间就可以加减了； b = a + datetime.datetime.today() # 当前时间 + 时间间隔（一周），赋值给 b; print(b) # 输出：2020-10-01 12:56:41.216884 输出一周后的时间，如果嫌弃秒后有小数，可以去掉； b.strftime('%Y-%m-%d %H:%M:%S') # 输出：2020-10-01 12:56:41， 这样就去掉了小数；

4.2 relativedelta()

该方法属于dateutil模块，所以需要先引入模块，才可以使用；引入方式如下：

from dateutil.relativedelta import relativedelta

引入后，可以通过该模块计算年，月，日，时，分，秒，周，工作日等；举例如下：

# 年，月，天，周，时，分，秒，工作日，闰年等都可以使用 relativedelta， from dateutil.relativedelta import relativedelta a = relativedelta(b) ''' 参数定义如下： dt1=None, dt2=None, years=0, months=0, days=0, leapdays=0, weeks=0, hours=0, minutes=0, seconds=0, microseconds=0, year=None, month=None, day=None, weekday=None, yearday=None, nlyearday=None, hour=None, minute=None, second=None, microsecond=None ''' # 上面的参数都可以是浮点型； a = datetime.datetime.today() # 当前时间：2020-10-01 12:54:38.821073 c = datetime.datetime.today() + relativedelta(days=0.5) print(c) # 输出一天后的时间：2020-09-25 12:54:38.828092 因为此时的c是datetime 类型，所以可以使用strftime()随意的制定输出格式； c.strftime('%Y-%m-%d %H:%M:%S') # 输出：2020-09-25 12:54:38 d= datetime.datetime.today() + relativedelta(years=1) print(d) # 输出一年后的时间：2021-09-24 12:55:59.793014 d.strftime('%Y-%m-%d %H:%M:%S') # 输出：2021-09-24 12:55:59

5. 实例

一般的项目中，可能并不需要我们对时间模块有过多的了解，所以需要时再回来看每个用法就可以了，下面举几个常用的例子，可以满足平时的大部分使用环境；

5.1 程序运行时间

# 1. 程序运行时间； import time a = time.time() # 记录开始时间 # 以下是函数体 i = 0 while i<1000000: i+=1 pass b = time.time() # 记录结束时间 print(b-a) # 输出：0.08823347091674805

5.2 时间类型的转换

应用场景：工业中设备生产 log 中一般包含时间信息，这些时间信息为字符串格式，当格式不满足使用习惯时，我们需要变更时间格式；例如：Wed Sep 23 17:52:55 2020 ==> 2020-9-23 17:52:55，实现代码如下：

# Wed Sep 23 17:52:55 2020 ==> 2020-9-23 17:52:55 import datetime a = 'Wed Sep 23 17:52:55 2020' # 原始的时间格式 b = datetime.datetime.strptime(a, '%a %b %d %H:%M:%S %Y') # 现在 b 就是 datetime 对象； %a %b %d %H:%M:%S %Y 与 Wed Sep 23 17:52:55 2020 一一对应；代表字符参考：1.2.8 自定义格式时的代表字符； print(b) # 输出：2020-09-23 17:52:55 # 当时间是datetime对象时，我们就可以使用 strftime()，随意去定制输出的格式了；举例如下： b.strftime('%Y-%m-%d %H:%M:%S') # 输出：2020-09-23 17:52:55 (字符串格式) b.strftime('%Y-%m-%d %H:%M') # 不要秒的格式：2020-09-23 17:52 b.strftime('%y-%m-%d %H:%M') # 简化的年：20-09-23 17:52

5.3 时间的运算；timedelta() & relativedelta()

计算今天(2020-09-24)的18天后是哪天；代码如下：

from dateutil.relativedelta import relativedelta a = datetime.datetime.today() # 输出：2020-09-24 13:19:25.642956 b = relativedelta(days=18) c = a + b # 此时c为：2020-10-12 13:19:25.642956 print(c) # 此时c为：2020-10-12 13:19:25.642956 print( a.strftime('%Y-%m-%d') + '的18天后是'+c.strftime('%Y-%m-%d')) # 格式化输出结果：2020-09-24的10天后是2020-10-12

5.4 固定时间运行程序

每隔10分钟，运行一次程序；

import time,os def sleep_time(hour,min,sec): return hour * 3600 + min * 30 +sec sleep = sleep_time(0,10,0) while True: time.sleep(sleep) print('开始执行；') print('现在时间为：' + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(a))) os.system(r'D:\print_fun.py') print('执行完成；')

每天早上 7:00 运行程序；

import time, os while True: time_now = time.strftime("%H:%M", time.localtime()) if time_now == '07:00': print('开始执行；') print('现在时间为：' + time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())) os.system(r'D:\print_fun.py') print('执行完成；') time.sleep(60) # 因为我们是以分钟作为匹配值的，所以程序运行后，延时60s,确保程序不重复执行；

5.5 打印进度条

def progress(percent,width=50): if percent > 1: percent=1 show_str=('[%%-%ds]' %width) %(int(width*percent) * '#') print('\r%s %d%%' %(show_str,int(100*percent)),end='') import time recv_size=0 total_size=100000 while recv_size < total_size: time.sleep(0.1) recv_size+=100 percent=recv_size / total_size progress(percent)

输出：