脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Python - Python学习之时间包使用教程详解

Python学习之时间包使用教程详解

2022-11-10 10:40渴望力量的哈士奇 Python

本文主要介绍了Python中的内置时间包：datetime包 与 time包 ，通过学习时间包可以让我们的开发过程中对时间进行轻松的处理，快来跟随小编一起学习一下吧

datetime 时间包

认识 datetime 时间包：

  • date：日期；time：时间；所以 datetime 就是 日期与时间的结合体
  • 使用 datetime 我们就可以获取当前的时间与时间间隔
  • 可以将时间对象转成时间字符串
  • 也可以将字符串转成时间类型(把字符串转成时间对象也是有格式要求的)

datetime 时间包的常用功能

获取当前的时间

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 导入包与模块
 
# 第一种导入方法：
from datetime import datetime   # 第一个 datetime 是包 ；第二个 datetime 是模块
 
# 第二种导入方法：
import datetime     # 直接导入 datetime 包
 
# *************************************************************************
 
# 使用方法：
 
# 如果我们使用第一种导入方法，那么我们就可以直接通过 datetime 模块调用 now() 函数：
print(datetime.now())
 
# >>> 执行结果如下：
# >>> 2020-01-16 14:20:19.534920
# >>> 返回的是当前 年、月、日、时、分、秒、毫秒的 datetime 对象
 
 
# 如果我们使用第二种导入方法，那么我们就需要 datetime.datetime.now() 的方式来调用now() 函数：
print(datetime.datetime.now())
 
# >>> 执行结果如下：
# >>> 2020-01-16 14:22:11.534920
# >>> 返回的是当前 年、月、日、时、分、秒、毫秒的 datetime 对象

获取时间间隔

其实获取时间间隔本身没有什么用，它需要配合我们刚刚提到的 datetime 模块的 now() 函数来配合使用。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 导入包
from datetime import datetime
from datetime import timedelta 
 
# 这里需要注意：timedelta 并不是模块，而是一个函数；
# 至于为什么不是模块，我们不进行深究；可以猜测一下， timedelta 可能是写在 datetime 包下 __init__.py 文件内被提前导入的函数
 
 
# 使用方法：
timeobj = timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
 
# days：间隔的天数
# seconds：间隔的秒数
# microseconds：间隔的毫秒数
# milliseconds：间隔的微秒数
# minutes：间隔的分钟数
# hours：间隔的小时数
# weeks：间隔的周数
 
# 这些参数我们可以全部传，也可以只传一个；像间隔一天、两天这种情况，我们就可以使用 hours 或 days
# 传入类型为 整型 ，支持整数与负数，一般我们建议使用正数。

datetime 时间包的小案例

结合获取当前时间与间隔，我们看一下下面这个小案例：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
from datetime import datetime
from datetime import timedelta
 
 
now = datetime.now()
print(now, type(now))
 
# >>> 执行结果如下：
# >>> 2020-01-16 15:04:00.492240 <class 'datetime.datetime'>
 
 
three_days = timedelta(days=3)
after_three_days = now + three_days
print('三天之后的时间是：', after_three_days)
 
# >>> 执行结果如下：
# >>> 三天之后的时间是： 2020-01-16 15:04:00.492240
 
 
before_three_days = now - three_days
print('三天之前的时间是：', after_three_days)
 
# >>> 执行结果如下：
# >>> 三天之前的时间是： 2020-01-16 15:04:00.492240
 
 
one_hour = timedelta(hours=1)
before_one_hour = now - one_hour
print('一小时之前的时间是：', before_one_hour)
 
# >>> 执行结果如下：
# >>> 一小时之前的时间是： 2020-01-16 14:04:00.492240

通过上面的小案例我们知道，时间对象之间我们可以做 加法与减法 的操作，但是时间对象有个问题。

它无法进行时间对象之间的传输，比如A服务想要给B服务传输一个时间对象，但是时间对象是无法传输的，必须先要转成字符串，然后才可以进行传输，接下来我们就学习一下如何将时间对象转成字符串。

时间对象转字符串

上文我们知道，想要获取时间对象就要调用 datetime 模块的 now() 函数，并且执行获取一个时间对象。

然后赋值给一个 now 变量，now 变量的值作为一个时间对象也会有自己的内置函数。

通过调用内置函数 strftime() 【strftime 是一个格式化字符串的标准】，通过这个字符化的标准就可以通过 format 将当前的日期时间对象按照 format 的标准转为时间字符串。

用法如下：

?
1
2
3
4
5
6
# 获取时间对象
from datetime import datetime
now = datetime.datetime.now()
 
# 时间对象转为字符串
date_str = now.strftime(format)

示例如下：

?
1
2
3
4
5
6
7
8
9
10
11
from datetime import datetime
 
 
date = datetime.now()
 
str_date = date.strftime('%Y-%m-%d %H:%M:%S')   # 括号内为时间类型的格式化标准的字符集合
print(str_date)
 
# >>> 执行结果如下：
# >>> 2020-01-16 15:44:26      # 符合时间格式的字符串
# >>> 其实还有更多的时间格式符，在下面会有详细介绍

接下来，我们用上面的 datetime 时间包的小案例 来实现我们的 时间对象转字符串 场景

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
from datetime import datetime
from datetime import timedelta
 
 
now = datetime.now()
# print(now, type(now))
now_str = now.strftime('%Y-%m-%d %H:%M:%S')
print(now_str, type(now_str))
 
# >>> 执行结果如下：
# >>> 2020-01-16 16:14:15 <class 'str'>      时间对象已经按照strftime标准格式化成了字符串类型
 
 
three_days = timedelta(days=3)
after_three_days = now + three_days
# print('三天之后的时间是：', after_three_days)
after_three_days_str = after_three_days.strftime('%Y/%m/%d %H:%M:%S')
print(after_three_days_str, type(after_three_days_str))
 
# >>> 执行结果如下：
# >>> 2020/01/16 16:19:35 <class 'str'>
# >>> 通过这里我们发现，只要我们只要保证格式符是我们想要的属性，格式的状态我们可以自己去定义
# >>> 甚至这些 '/' 都可以不需要，看下面的运行结果
 
 
after_three_days_str = after_three_days.strftime('%Y%m%d')
print(after_three_days_str, type(after_three_days_str))
                                                 
# >>> 执行结果如下：
# >>> 20220313 <class 'str'>
# >>> 验证了格式的状态我们可以自己去定义的想法，甚至我们都没有输出 时、分、秒

时间字符串转时间类型

时间字符串转时间类型方法如下：

?
1
2
3
4
5
6
7
8
9
# 获取时间模块
from datetime import datetime
 
# 时间字符串转时间类型
datetime.strptime(tt,format)
 
# 参数介绍：
# tt：符合时间格式的字符串
# format：tt时间字符串匹配规则

示例如下：

?
1
2
3
4
5
6
7
8
9
10
from datetime import datetime
 
 
str_date = '2020-01-01 08:08:08'
date_obj = datetime.strptime(str_date, '%Y-%m-%d %H:%M:%S') # 格式化标准要与时间字符串匹配
 
print(date_obj, type(date_obj))
 
# >>> 执行结果如下：
# >>> 2020-01-01 08:08:08 <class 'datetime.datetime'>

同样的使用 datetime 时间包的小案例 来实现我们的 时间字符串转时间类型 场景

?
1
2
3
4
5
6
7
8
9
10
11
12
13
from datetime import datetime
from datetime import timedelta
 
 
now = datetime.now()
# print(now, type(now))
now_str = now.strftime('%Y-%m-%d %H:%M:%S')
# print(now_str, type(now_str))
now_obj = datetime.strptime(now_str, '%Y-%m-%d %H:%M:%S')
print(now_obj, type(now_obj))
 
# >>> 执行结果如下：
# >>> 2020-01-10 18:00:54 <class 'datetime.datetime'>

上面我们进行 时间对象转字符串的时候，将时间对象的 '%Y-%m-%d %H:%M:%S' 格式进行了取舍，只输出了 '%Y-%m-%d' ; 这我们尝试 时间字符串转为时间类型 同样做一个取舍试一下，也只保留 '%Y-%m-%d

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
from datetime import datetime
from datetime import timedelta
 
 
now = datetime.now()
 
three_days = timedelta(days=3)
after_three_days = now + three_days
# print('三天之后的时间是：', after_three_days)
after_three_days_str = after_three_days.strftime('%Y/%m/%d %H:%M:%S')
# print(after_three_days_str, type(after_three_days_str))
 
after_three_days_obj = datetime.strptime(after_three_days_str, '%Y/%m/%d')
print(after_three_days_obj, type(after_three_days_obj))
 
# >>> 执行结果如下：
# >>> ValueError: time data '2020/01/13 18:22:19' does not match format '%Y%m%d'
# >>> 这里提示我们 格式符 与 字符串 不匹配，所以当时间字符串转为时间类型时，格式状态要保持一致
 
 
# 补上 时、分、秒 看看运行结果
 
after_three_days_obj = datetime.strptime(after_three_days_str, '%Y/%m/%d %H:%M:%S')
print(after_three_days_obj, type(after_three_days_obj))
    
# >>> 执行结果如下：
# >>> 2020-01-13 18:26:58 <class 'datetime.datetime'>

接下来我们再看看被我们 使用 '%Y/%m/%d' 截断的 时间类型转为字符串，再转为时间类型会是怎样的输出结果。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
from datetime import datetime
from datetime import timedelta
 
 
now = datetime.now()
 
three_days = timedelta(days=3)
before_three_days = now - three_days
# print('三天之前的时间是：', after_three_days)
before_three_days_str = before_three_days.strftime('%Y%m%d')
# print(before_three_days_str, type(before_three_days_str))
before_three_days_obj = datetime.strptime(before_three_days_str, '%Y%m%d')
print(before_three_days_obj, type(before_three_days_obj))
 
# >>> 执行结果如下：
# >>> 2020-01-13 00:00:00 <class 'datetime.datetime'>
# >>> 这里我们发现，时间类型转为字符串，再转为时间类型，由于使用 '%Y/%m/%d' 截断转为字符串的原因
# >>> 在再次转为 时间类型 后，它的输出结果的 时、分、秒 部分变成了 00:00:00

非时间格式字符串转时间类型

我们直接定义一个 非时间格式的字符串，尝试转为 时间类型 看看会有怎样的结果

?
1
2
3
4
5
6
7
8
9
10
11
from datetime import datetime
from datetime import timedelta
 
 
date_time = '2020 01 A'
print(datetime.strptime(date_time, '%Y %m'))
 
# >>> 执行结果如下：
# >>> ValueError: unconverted data remains:  A
# >>> 这里报错信息为：不知道 A 对应的格式是什么，字符串格式中，我们也没有对 A 使用格式化方法；
# >>> 同时，date_time 也是一个非标准的时间格式字符串，我们没有办法对其进行时间格式的转换

时间格式符

字符 介绍
%Y 完成的年份 如2020
%m 月份， 1-12
%d 月的某一天，1-31
%H 一天中的第几个小时，24小时(00-23)
%I 一天中的第几个小时，12小时(01-12)
%M 当前的第几分钟(00-59)
%S 当前分的第几秒(00-61) 多出来的两秒是闰年的
%f  当前秒的第几毫秒
%a 简化的星期，如Wed
%A 完整的星期，如Wednesday
%b 简化的月份，如二月 Feb
%B 完整的月份，如二月 February
%c  本地的日期和时间，如 Wed Feb 5 10:14:30 2020
%p  上午或下午；AM 为上午 ，PM为下午
%j 一年中的第几天
%U 一年中的星期数

time模块

在上文我们学习 python 中第一个内置包 datetime （日期时间包），学习了如何使用 datetime 如何获取当前的日期对象以及日期对象与日期字符串之间的互相转换。

接下来我们学习一下 python 中的 第一个内置模块，它也是用来处理时间的，那就是 time 模块。学会使用 time 模块，可以丰满我们对时间的处理。

认识时间戳

什么是时间戳？其实时间戳就是时间，只不过他的起始时间有所不同。

  • 时间戳是从 1970年1月1日00时00分00秒至今的总毫秒（秒）数 ；Python 默认是按秒来计算时间戳的。
  • 在 python 中，用 timestamp 来表示时间戳
  • 在 python 中，时间戳 是一个 float 类型。我们使用 datetime 获取时间对象是可以看到 年月日、时分秒的；而时间戳展示给我们是从 1970年1月1日00时00分00秒至今的秒数(时间戳可以转成我们可读的 年月日、时分秒格式，我们稍后就会学习如何使用)。
  • time 模块的总体功能就是为了处理时间与转换格式

time 模块与它的函数们：

1.时间处理，转换成时间格式

2.time 函数 ，生成时间戳数

3.localtime 函数，获取本地时间函数

localtime 函数 需要了解对应的字段介绍

4.sleep 函数 ，暂停/休眠/等待

5.strftime 函数，将时间对象转为字符串

6.strptime 函数，将时间字符串转为时间对象

time 模块的常用方法

?
1
2
3
4
5
6
7
8
9
10
11
# 导入包；
import time
 
# 使用方法：
time.time()
 
# 返回值：
# 秒级别的浮点类型
 
# 示例：
# 1580878485.4009378

注意：每个语言返回的时间戳格式都不太一样，有的是返回秒级别，有的是返回毫秒级别。无论哪一种，时间都是一样的，只是 秒 与 毫秒 之间的转换而已。

获取本地时间函数 - localtime

?
1
2
3
4
5
6
7
8
9
# 导入包；
import time
 
# 使用方法：
time.localtime(timestamp)
 
# 参数介绍：
# timestamp：可以传入一个时间戳，传入后 localtime() 函数会将传入的时间戳转为 时间对象。
# 可以不传入，如果不传入时间戳；会默认返回当前最新的时间对象。

示例如下：

?
1
2
3
4
5
6
7
8
9
10
import time
 
 
test_time = time.localtime()
 
print(test_time)
 
# >>> 执行结果如下：
# >>> time.struct_time(tm_year=2022, tm_mon=3, tm_mday=11, tm_hour=13, tm_min=33, tm_sec=52, tm_wday=4, tm_yday=70, tm_isdst=0)
# >>> 输出的是 localtime 字段信息

localtime 对应字段信息介绍

属性名 介绍 取值范围
tm_year 四位数的年单位 1970~∞
tm_mon 月 1~12
tm_mday 日 1~31
tm_hour 小时 0~23
tm_min 分钟 0~59
tm_sec 秒 0~61（闰年会多两秒）
tm_wday 一周的第几天 0~6（0是周一）
tm_yday 一年的第几日 1~366（支持儒略历，现用的是格里历即公历）
tm_isdst  夏令时 -1 或 0 ；1 代表是否是夏时令

来看一下 localtime 函数 的小案例

?
1
2
3
4
5
6
7
8
9
10
11
12
13
import time
 
 
test_time = time.time()
test_time_obj = time.localtime(test_time)
 
print(test_time_obj, type(test_time_obj))
 
# >>> 执行结果如下：
# >>> 1578898063.2553177
# >>> time.struct_time(tm_year=2020, tm_mon=1, tm_mday=13, tm_hour=14, tm_min=46, tm_sec=44, tm_wday=4, tm_yday=70, tm_isdst=0) <class 'time.struct_time'>
 
# >>> 通过这样的方式，就可以将我们的时间戳转为 time.struct_time 的时间对象，可读性会变得很好

上文我们提到过，localtime() 函数内可以不传入参数，获取的是当前最新的时间对象。我们也来看一下：

?
1
2
3
4
5
6
7
8
import time
 
 
current_time = time.localtime()
print(current_time)
 
# >>> 执行结果如下：
# >>> time.struct_time(tm_year=2022, tm_mon=1, tm_mday=13, tm_hour=14, tm_min=57, tm_sec=47, tm_wday=4, tm_yday=70, tm_isdst=0)

刚刚提到过，我们的 python 获取的是秒级别的时间戳，如果我们想要获取 毫秒 级别的时间戳要怎么办？其实很签单，我们只需要需要将获取的时间戳 *1000（乘以1000就可以了）就可以获取 毫秒级 的时间戳了。

?
1
2
3
4
5
6
7
8
9
10
11
import time
 
 
print(time.time())
print(time.time() * 1000)
 
# >>> 执行结果如下：
# >>> 1646982476.7887278
# >>> 1646982476788.7278
 
# >>> 上下比对一下，发现我们的 秒级别 时间戳已经变为了 毫秒级 的时间戳了

暂停函数 - sleep

sleep()：名如其实，该函数会将我们的程序暂停执行一段时间。

?
1
2
3
4
5
6
7
8
# 导入包；
import time
 
# 使用方法：
time.sleep(second)
 
# 参数介绍：
# second：希望程序被暂停执行的秒数

示例如下：

?
1
2
3
4
5
6
7
8
import time
 
 
for i in range(5):
    print(i)
    time.sleep(1)
    
# >>> 大家可以在自己电脑上试试运行效果

time 中的 strftime

?
1
2
3
4
5
6
7
8
9
10
11
# 导入包；
import time
 
# 使用方法：
time.strftime(format, t)
 
# 参数介绍：
# format：时间的格式化规范
# t：time.localtime 对应的时间类型
 
# >>> 其实用法与前文介绍的 datetime 的 strftime 完全一致，只不过对应的对象是 time 的时间对象

示例如下：

?
1
2
3
4
5
6
7
8
import time
 
 
str_time = time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
print(str_time)
 
# >>> 执行结果如下：
# >>> 2020-01-13 16:22:21

time 中的 strptime

?
1
2
3
4
5
6
7
8
9
# 导入包；
import time
 
# 使用方法：
time.strptime(time_str, format)
 
# 参数介绍：
# time_str：符合时间格式的字符串
# format：确保与 time_str 一致的格式化标准(字符串的内容都都可以通过 时间格式符 匹配上)

示例如下：

?
1
2
3
4
5
6
7
8
import time
 
 
obj_time = time.strptime('2020-01-13', '%Y-%m-%d')
print(obj_time)
 
# >>> 执行结果如下：
# >>> time.struct_time(tm_year=2020, tm_mon=1, tm_mday=13, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=13, tm_isdst=-1)

datetime 中生成时间戳的函数

前文我们在讲解 datetime 包的时候，并没有讲解如何使用 datetime 中生成时间戳，现在顺着 时间戳部分一起带出来。

?
1
2
3
4
5
6
7
8
9
10
11
# 导入包；
import datetime
 
# 使用方法：
now = datetime.datetime.now()
datetime.datetime.timestamp(now)   
# 不同于 time 模块的 time 函数 的生成 时间戳
# 而是将一个 datetime 对象 转为时间戳，所以括弧中不传入参数是会报错的。
 
# 参数介绍：
# now：datetime 的时间对象

示例如下：

?
1
2
3
4
5
6
7
8
9
10
import datetime
 
 
now = datetime.datetime.now()
now_timestamp = datetime.datetime.timestamp(now)
 
print(now_timestamp, type(now_timestamp))
 
# >>> 执行结果如下：
# >>> 1642067213.882046 <class 'float'>          秒级别的时间戳，浮点类型

datetime 时间戳转时间对象

?
1
2
3
4
5
6
7
8
9
10
11
# 导入包；
import datetime
 
# 使用方法：
datetime.datetime.fromtimestamp(timestamp)
 
# 参数介绍：
# timestamp：时间戳
 
# 返回值：
# 返回一个 datetimes 的日期对象

示例如下：

?
1
2
3
4
5
6
7
8
9
10
11
12
import datetime
 
 
now = datetime.datetime.now()
now_timestamp = datetime.datetime.timestamp(now)
 
datetime_obj = datetime.datetime.fromtimestamp(now_timestamp)
 
print(datetime_obj, type(datetime_obj))
 
# >>> 执行结果如下：
# >>> 2020-01-13 17:43:08.795082  <class 'datetime.datetime'>

可能大家会有个疑问，既然 datetime 包 与 time 模块的功能很多都是一样的，那么为什么会有这两个包和模块的存在呢？

其实，在实际工作中 datetime 包更多的是对于日期的处理；而 time 模块更多的则是对时间的处理，比如 时、分、秒 这样的格式，使用 time 模块来处理会更合适一些。

到此这篇关于Python学习之时间包使用教程详解的文章就介绍到这了,更多相关Python时间包内容请搜索服务器之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持服务器之家！

原文链接：https://blog.csdn.net/weixin_42250835/article/details/123604241

  • Python
  • 时间
  • 包

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    2048 　 6006 　 contextlib 　 SLOTS 　 MELIAE 　 FEEDPARSER 　 暂存 　 持久性管理 　 pickle模块 　 THREADING 　 reduce 　 nignx 　 装饰器 　 函数式编程 　 兔子毒药 　 监控文件 　 流量监控 　 Web框架 　 灰狼优化算法 　 PIL库 　 高斯模糊 　 wxPython 　 import 　 自定义模块 　 Python开发 　 元类 　 metaclass 　 魔术方法 　 DNSPod 　 动态解析域名 　
    © 2019-2022 脚本之家 | 服务器之家(www.tuohang.net)旗下站点 版权所有关于我们联系我们版权申明网站地图