datetime 时间和日期模块
datetime 模块提供了以简单和复杂的方式操作日期和时间的类。虽然支持日期和时间算法，但实现的重点是有效的成员提取以进行输出格式化和操作。该模块还支持可感知时区的对象。
本文主要介绍datetime库的一些基本的使用方法。
timestamp：时间戳，指格林威治时间1970年01月01日00时00分00秒（北京时间1970年01月01日08时00分00秒）起至现在的总秒数
utc：世界协调时间（Universal Time Coordinated,UTC）
GPS 系统中有两种时间区分，一为UTC，另一为LT（地方时），两者的区别为时区不同，UTC就是0时区的时间，地方时为本地时间，如北京为早上八点（东八区），UTC时间就为零点，时间比北京时晚八小时，以此计算即可。
文章目录
- datetime 时间和日期模块
- 1. 常用用法
- 1.1
- 1.2
- 1.3
- 1.4
- 1.5
- 2. 模块内格式字符的含义一览表
- 结束语
1. 常用用法
datetime库中定义的几个类：
| 类名称 | 描述 | 常用属性 |
|---|---|---|
| 表示日期 | year, month, day | |
| 表示时间 | hour, minute, second, microsecond | |
| 表示日期和时间 | year, month, day, hour, minute, microsecond | |
| 表示两个日期时间之间的差 | days, hours, seconds | |
| 描述时区信息对象的抽象基类 | 上网查找 | |
| 时区，表示与UTC的固定偏移量 | 对象 |
导入：
import datetime as datet
from datetime import date, time, datetime, timedelta, timezone
- 1
- 2
运行
常量：
| 常量 | 描述 | 值 |
|---|---|---|
| date 或 datetime 对象允许的最小年份 | 1 | |
| date 或 datetime 对象允许最大的年份 | 9999 |
1.1
date 对象代表一个理想化历法中的日期（年、月和日），即当今的格列高利历向前后两个方向无限延伸。
from datetime import date
- 1
运行
实例化一个date对象：
d = date(year=2021,month=1,day=1) #一种方法
d = date(2021,1,1) #更简单一些
- 1
- 2
date类的方法和属性：
| 方法和属性 | 描述 |
|---|---|
| date类所能表示的最大日期 | |
| date类所能表示的最小日期 | |
| 日期的最小单位，即两个不同日期的最小差值，返回timedelta对象 | |
| () | 获取今天的日期 |
| (timestamp) | 用时间戳获取日期 |
| (‘xxxx-xx-xx’) | 将特定格式日期字符串转换为date对象 |
| (year,week,weekday) | 以年、一年中第几个星期、星期几获取日期 |
| (int) | 用0001-01-01至该日期的天数获取日期 |
date对象的方法和属性：
| 方法和属性 | 描述 |
|---|---|
| 获取年 | |
| 获取月 | |
| 获取日 | |
| () | 获取该日期是星期几，范围0~6，0表示星期一 |
| () | 获取该日期是星期几，范围1~7，1表示星期一 |
| (year[,month[,day]]) | 生成并返回一个新的日期对象，原日期对象不变 |
| () | 返回一个表示日期的字符串 |
| () | 返回该日期的’xxxx-xx-xx’字符串格式 |
| () | 返回该日期的(year,week,weekday)元组格式 |
| () | 返回该日期对应的time.struct_time对象 |
| () | 返回从0001-01-01至该日期的天数 |
| (format) | 返回指定格式的日期字符串 |
示例：
>>> from datetime import date #导入date模块
>>> import time
>>> stamptime = time.time() #导入time库获取时间戳
>>> date.today() #获取当天时间
datetime.date(2021, 6, 26)
>>> date.max #获取date类所能表示的最大日期
datetime.date(9999, 12, 31)
>>> date.min #获取date类所能表示的最小日期
datetime.date(1, 1, 1)
>>> date.resolution #获取日期间隔的最小单位
datetime.timedelta(days=1)
>>> date.fromtimestamp(time.time()) #用时间戳获取日期
datetime.date(2021, 6, 26)
>>> date.fromisoformat('2021-01-01') #用'xxxx-xx-xx'格式字符串获取日期
datetime.date(2021, 1, 1)
>>> date.fromisocalendar(2020,1,3) #以年、一年中第几个星期、星期几获取日期
datetime.date(2020, 1, 1)
>>> date.fromordinal(737425) #用0001-01-01至该日期的天数获取日期
datetime.date(2020, 1, 1)
>>> d = date(2020,1,1) #生成日期
>>> d
datetime.date(2020, 1, 1)
>>> print(d) #注意打印出来的日期会自动安排格式
2020-01-01
>>> d.year #获取年
2020
>>> d.month #获取月
1
>>> d.day #获取日
1
>>> d.replace(1949,10,1) #生成并返回一个新的日期对象，原日期对象不变
datetime.date(1949, 10, 1)
>>> d #原日期对象不变
datetime.date(2020, 1, 1)
>>> d.ctime() #返回一个表示日期的字符串
'Wed Jan 1 00:00:00 2020'
>>> d.weekday() #对应星期几，范围0~6
2
>>> d.isoweekday() #对应星期几，范围1~7
3
>>> d.isoformat() #返回该日期的'xxxx-xx-xx'字符串格式
'2020-01-01'
>>> d.isocalendar() #返回该日期的(year,week,weekday)元组格式
(2020, 1, 3)
>>> d.timetuple() #返回该日期对应的time.struct_time对象
time.struct_time(tm_year=2020, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=1, tm_isdst=-1)
>>> d.toordinal() #返回从0001-01-01至该日期的天数
737425
>>> d.strftime('date:%Y/%m/%d') #返回指定格式的日期字符串，其中可放置字符串和模块内其他格式字符(见文末)，好像不能有中文
'date:2020/01/01'
- 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
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
1.2
一个 time 对象代表某日的（本地）时间，它独立于任何特定日期，并可通过 tzinfo 对象来调整。
import datetime as datet
from datetime import time, timedelta, timezone
- 1
- 2
运行
实例化一个time对象：
t = time(hour=12,minute=30,second=55,tzinfo=timezone.utc) #制定时区实例化一个time对象，tzinfo可选
t = time(12,30,55) #简略一些
- 1
- 2
time类的方法和属性：
| 方法和属性 | 描述 |
|---|---|
| time类所能表示的最大时间 | |
| time类所能表示的最小时间 | |
| 时间的最小单位，即两个不同时间的最小差值，返回timedelta对象 | |
| (xx:xx:xx) | 将特定格式时间字符串转换为time对象 |
time对象的方法和属性：
| 方法和属性 | 描述 |
|---|---|
| 获取时 | |
| 获取分 | |
| 获取秒 | |
| 获取微秒 | |
| 获取时区信息 | |
| () | 获取时区名称 |
| () | 获取与utc时区的时间偏移量，为timedelta对象 |
| () | 返回该日期时间的’xx:xx:xx’字符串格式,如果该时间相比utc有偏移，即有指定时区，则会附上偏移量。 |
| ([,hour[, minute[, second[, microsecond[, tzinfo]]]]]) | 生成并返回一个新的time对象，原对象不变 |
| (format) | 返回指定格式的时间字符串 |
示例：
>>> import datetime as datet #导入库和模块
>>> from datetime import time, timedelta, timezone
>>> time.max #time类所能表示的最大时间
datetime.time(23, 59, 59, 999999)
>>> time.min #time类所能表示的最大时间
datetime.time(0, 0)
>>> time.resolution #时间的最小单位，即两个不同时间的最小差值，返回timedelta对象
datetime.timedelta(microseconds=1)
>>> time.fromisoformat('12:30:55') #将特定格式时间字符串转换为time对象
datetime.time(12, 30, 55)
>>> t = time(12,30,55,tzinfo=timezone.utc) #指定时区实例化一个time对象
>>> t
datetime.time(12, 30, 55, tzinfo=datetime.timezone.utc)
>>> print(t)
12:30:55+00:00 #注意打印出来的会自动格式化，如果指定了时区则附上偏移量
>>> t.hour #获取时
12
>>> t.minute #获取分
30
>>> t.second #获取秒
55
>>> t.microsecond #获取微秒
0
>>> t.tzinfo #获取时区信息
datetime.timezone.utc
>>> t.tzname() #获取时区名称
'UTC'
>>> t.utcoffset() #获取偏移量
datetime.timedelta(0)
>>> t.isoformat() #用特定格式字符串获取时间
'12:30:55+00:00'
>>> t.replace(9,30) #生成并返回一个新的time对象，原对象不变
datetime.time(9, 30, 55, tzinfo=datetime.timezone.utc)
>>> t.strftime('time:%H:%M:%S') #返回指定格式的时间字符串
'time:12:30:55'
- 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
- 33
- 34
- 35
- 36
- 37
- 38
1.3
datetime 对象是包含来自 date 对象和 time 对象的所有信息的单一对象。
import datetime as datet
from datetime import datetime, timezone
- 1
- 2
运行
实例化一个datetime对象：
dt = datetime(year=2021,month=1,day=1,hour=12,minute=30,second=55) #实例化
dt = datetime(2021,1,1,12,30,55) #更加简单一些
dt = datetime(2021,1,1,12,30,55,tzinfo=timezone.utc) #指定时区的方法
- 1
- 2
- 3
datetime类的方法和属性：
| 方法和属性 | 描述 |
|---|---|
| datetime类所能表示的最大日期时间 | |
| datetime类所能表示的最小日期时间 | |
| 时间的最小单位，即两个不同时间的最小差值，返回timedelta对象 | |
| () | 获取当前日期和时间 |
| (tz) | 获取指定时区的当前日期时间，如果不指定tz参数则结果同上 |
| () | 获取当前utc日期时间 |
| (timestamp[, tz]) | 用时间戳获取时间 |
| (timestamp) | 用时间戳获取utc时间 |
| (date, time) | 合并date和time对象 |
| (‘datetime’,format) | 将时间字符串转换为datetime对象 |
datetime对象的方法和属性：
| 方法和属性 | 描述 |
|---|---|
| 获取年 | |
| 获取月 | |
| 获取日 | |
| 获取时 | |
| 获取分 | |
| 获取秒 | |
| 获取微秒 | |
| () | 获取datetime对象对应的date对象 |
| () | 获取datetime对象对应的time对象，tzinfo为None |
| 获取时区信息 | |
| () | 获取时区名称 |
| () | 获取与UTC时区的时间偏移量，为timedelta对象 |
| () | 获取datetime对象对应的time对象和tzinfo |
| () | 返回一个表示日期的字符串 |
| () | 获取该日期是星期几，范围0~6，0表示星期一，同date |
| () | 获取该日期是星期几，范围1~7，1表示星期一，同date |
| ([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]]) | 生成并返回一个新的datetime对象，原对象不变 |
| (tz) | 生成并返回一个新的datetime对象，改变其tzinfo，原对象不变 |
| () | 根据datetime对象的tzinfo，返回是否夏令时 |
| (sep,timespec) | 返回该日期时间的’xxxx-xx-xx xx:xx:xx’字符串格式，sep为日期和时间间的分隔符，默认为T，timespec为时间部分显示模式选择(参见示例)，如果该时间相比utc有偏移，即有指定时区，则会附上偏移量。 |
| () | 返回该日期时间的(year,week,weekday)元组格式，同date |
| () | 返回该日期时间对应的time.struct_time对象(不包括tzinfo) |
| () | 返回该日期时间对应的utc时区time.struct_time对象(不包括tzinfo) |
| () | 返回从0001-01-01至该日期的天数，同date |
| (format) | 返回指定格式的日期时间字符串 |
示例：
>>> import datetime as datet #导入库和模块
>>> from datetime import datetime, timezone
>>> datetime.max #datetime类所能表示的最大日期时间
datetime.datetime(9999, 12, 31, 23, 59, 59, 999999)
>>> datetime.min #datetime类所能表示的最小日期时间
datetime.datetime(1, 1, 1, 0, 0)
>>> datetime.resolution #时间的最小单位，即两个不同时间的最小差值，返回timedelta对象
datetime.timedelta(microseconds=1)
>>> datetime.today() #获取当前日期和时间
datetime.datetime(2021, 6, 27, 8, 2, 19, 708118)
>>> datetime.now() #获取当前日期时间
datetime.datetime(2021, 6, 27, 8, 2, 31, 65767)
>>> datetime.now(tz=timezone(timedelta(hours=8))) #获取指定时区的当前日期时间
datetime.datetime(2021, 6, 27, 8, 3, 50, 882333, tzinfo=datetime.timezone(datetime.timedelta(seconds=28800)))
>>> datetime.utcnow() #获取当前utc日期时间
datetime.datetime(2021, 6, 27, 0, 6, 19, 706845) #可以看到，utc时间与我们北京时间是差了八个小时的
>>>datetime.fromtimestamp(1624753068.8182602,tz=timezone(timedelta(hours=8))) #用时间戳获取时间，指定时区
datetime.datetime(2021, 6, 27, 8, 17, 48, 818260, tzinfo=datetime.timezone(datetime.timedelta(seconds=28800)))
>>> datetime.utcfromtimestamp(1624753068.8182602) #用时间戳获取utc时间
datetime.datetime(2021, 6, 27, 0, 17, 48, 818260) #差了八个小时
>>> datetime.fromisocalendar(2020, 53, 5) #以年、一年中第几个星期、星期几获取日期
datetime.datetime(2021, 1, 1, 0, 0)
>>> datetime.fromisoformat('2021-01-01T12:30:55') #用特定格式字符串获取时间，注意日期和时间中间用T连接
datetime.datetime(2021, 1, 1, 12, 30, 55)
>>> datetime.fromordinal(737791) #用0001-01-01至该日期的天数获取日期
datetime.datetime(2021, 1, 1, 0, 0)
>>> d = date(2021,1,1)
>>> t = time(12,30,50)
>>> datetime.combine(d,t,tzinfo=timezone(timedelta(hours=8))) #用combine合并日期和时间，如果不指定时区则使用time的时区
datetime.datetime(2021, 1, 1, 12, 30, 50, tzinfo=datetime.timezone(datetime.timedelta(seconds=28800)))
>>> datetime.strptime('date:2021-01-01,time:12:30:50','date:%Y-%m-%d,time:%H:%M:%S') #字符串转时间
datetime.datetime(2021, 1, 1, 12, 30, 50)
>>> dt = datetime(2021,1,1,12,30,55,tzinfo=timezone.utc) #带时区实例化一个datetime
>>> dt
datetime.datetime(2021, 1, 1, 12, 30, 55, tzinfo=datetime.timezone.utc)
>>> print(dt)
2021-01-01 12:30:55+00:00 #注意打印出来的会自动格式化，如果指定了时区则附上偏移量
>>> dt.year #以下是获取年、月、日、时、分、秒、微秒
2021
>>> dt.month
1
>>> dt.day
1
>>> dt.hour
12
>>> dt.minute
30
>>> dt.second
55
>>> dt.microsecond
0
>>> dt.date() #获取datetime对象对应的date对象
datetime.date(2021, 1, 1)
>>> dt.time() #获取datetime对象对应的time对象
datetime.time(12, 30, 55)
>>> dt.tzinfo #获取时区信息
datetime.timezone.utc
>>> dt.tzname() #获取时区名称
'UTC'
>>> dt2 = datetime(2021,1,1,12,59,59,tzinfo=timezone(timedelta(hours=8),name='Beijing')) #自定义时区名称
>>> dt2.tzname() #获取时区名称
'Beijing'
>>> dt2.utcoffset() #获取偏移量
datetime.timedelta(seconds=28800)
>>> dt.timetz() #获取datetime对象对应的time对象和tzinfo
datetime.time(12, 30, 55, tzinfo=datetime.timezone.utc)
>>> dt.ctime()
'Fri Jan 1 12:30:55 2021'
>>> dt.weekday() #获取该日期是星期几，范围0~6，0表示星期一，同date
4
>>> dt.isoweekday() #获取该日期是星期几，范围1~7，1表示星期一，同date
5
>>> dt.replace(1949,10,1) #生成并返回一个新的datetime对象，原对象不变
datetime.datetime(1949, 10, 1, 12, 30, 55, tzinfo=datetime.timezone.utc)
>>> dt.astimezone(tz=timezone(timedelta(hours=8))) #生成并返回一个新的datetime对象，改变其tzinfo，原对象不变
datetime.datetime(2021, 1, 1, 20, 30, 55, tzinfo=datetime.timezone(datetime.timedelta(seconds=28800)))
>>> dt.isoformat() #返回该日期时间的'xxxx-xx-xx xx:xx:xx'字符串格式，sep为日期和时间间的分隔符，默认为T，timespec为时间部分显示模式选择
'2021-01-01T12:30:55+00:00'
>>> dt.isoformat(sep=' ',timespec='minutes') #timespec为时间部分显示模式选择，如果该时间相比utc有偏移，即有指定时区，则会附上偏移量。
'2021-01-01 12:30+00:00'
'''
timespec参数及其format
auto：根据time对象的时间内容，自动选择模式
hours：HH
minutes：HH:MM
seconds：HH:MM:SS
microseconds：HH:MM:
milliseconds：HH:MM:
注：除了milliseconds,其他模式，如果出现了时间偏移量offsetime,则需要加上偏移量
'''
>>> dt.isocalendar() #返回该日期时间的(year,week,weekday)元组格式，同date
(2020, 53, 5)
>>> dt.timetuple() #返回该日期时间对应的time.struct_time对象(不包括tzinfo)
time.struct_time(tm_year=2021, tm_mon=1, tm_mday=1, tm_hour=12, tm_min=30, tm_sec=55, tm_wday=4, tm_yday=1, tm_isdst=-1)
>>> dt.utctimetuple() #返回该日期时间对应的utc时区time.struct_time对象(不包括tzinfo)
time.struct_time(tm_year=2021, tm_mon=1, tm_mday=1, tm_hour=12, tm_min=30, tm_sec=55, tm_wday=4, tm_yday=1, tm_isdst=0)
>>> dt.toordinal() #返回从0001-01-01至该日期的天数，同date
737791
>>> dt.strftime('date:%Y-%m-%d,time:%H:%M:%S') #返回指定格式的日期字符串，其中可放置字符串和模块内其他格式字符(见文末)，好像不能有中文
'date:2021-01-01,time:12:30:55'
- 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
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
1.4
timedelta 对象表示两个 date 或者 time 的时间间隔。
import datetime as datet
from datetime import date, time, datetime, timedelta, timezone
- 1
- 2
运行
timedelta 类的参数：
| 参数 | 含义 |
|---|---|
| days | 天 |
| seconds | 秒 |
| microseconds | 微秒 |
| milliseconds | 毫秒 |
| minutes | 分钟 |
| hours | 小时 |
| weeks | 周 |
| 所有参数都可选，可为int、float和正数、负数。内部值只存储days、seconds 和 microseconds，因此其他所有参数的单位都会被转换： |
-
1毫秒 转换为 1000微秒： 1milliseconds = 1000microseconds
-
1分钟 转换为 60秒： 1minutes = 60seconds
-
1小时 转换为 3600秒： 1hours = 3600seconds
-
1星期 转换为 7天： 1weeks = 7days
实例化一个timedelta对象：
delta = timedelta(days=10,seconds=5,microseconds=5555,minutes=30,hours=12,weeks=2)
- 1
timedelta类的方法和属性：
| 方法和属性 | 描述 |
|---|---|
| timedelta类所能表示的最大时间间隔 | |
| timedleta类所能表示的最小时间间隔 | |
| timedelta类所能表示的时间间隔的最小单位 |
timedelta对象的方法和属性：
| 方法和属性 | 描述 |
|---|---|
| 获取timedelta对象经过单位换算后的总天数 | |
| 获取timedelta对象经过单位换算后的总秒数 | |
| 获取timedelta对象经过单位换算后的总微秒数 | |
| delta.total_seconds() | 获取timedelta对象包含的总秒数 |
使用timedelta对象可以对日期、时间进行求差、加减、比较等操作。
示例：
>>> import datetime as datet
>>> from datetime import datetime, timedelta
>>> timedelta.max #timedelta类所能表示的最大时间间隔
datetime.timedelta(days=999999999, seconds=86399, microseconds=999999)
>>> timedelta.min #timedleta类所能表示的最小时间间隔
datetime.timedelta(days=-999999999)
>>> timedelta.resolution #timedelta类所能表示的时间间隔的最小单位
datetime.timedelta(microseconds=1)
>>> delta = timedelta(days=10,seconds=5,microseconds=5555,minutes=30,hours=12,weeks=2) #实例化一个timedelta对象
>>> delta
datetime.timedelta(days=24, seconds=45005, microseconds=5555)
>>> print(delta) #注意打印出来的会自动格式化
24 days, 12:30:05.005555
>>> delta.days #获取timedelta对象经过单位换算后的总天数
24
>>> delta.seconds #获取timedelta对象经过单位换算后的总秒数
45005
>>> delta.microseconds #获取timedelta对象经过单位换算后的总微秒数
5555
>>> delta.total_seconds() #获取timedelta对象包含的总秒数
2118605.005555
>>> dt1 = datetime(2021,1,1,12,30,55)
>>> dt2 = datetime(2020,1,1,9,30,00)
>>> dt1 - dt2 #大减小
datetime.timedelta(days=366, seconds=10855)
>>> dt2 - dt1 #小减大
datetime.timedelta(days=-367, seconds=75545)
#以上方法求两个时间的差值
>>> dt1 + timedelta(seconds=5) #5秒后
datetime.datetime(2021, 1, 1, 12, 31)
>>> dt1 - timedelta(seconds=5) #5秒前，第一种方法：直接减去timedelta对象
datetime.datetime(2021, 1, 1, 12, 30, 50)
>>> dt1 + timedelta(seconds=-5) #5秒前，第二种方法：tamedelta对象参数设为正、负数以加减
datetime.datetime(2021, 1, 1, 12, 30, 50)
#以上方法可将时间向前、向后延迟
>>> (dt1 - dt2).total_seconds() #计算时间差总秒数
31633255.0
>>> dt1>dt2
True
>>> dt1<dt2
False
>>> dt1 == dt2
False
#比较大小
- 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
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
拓展：计算时间差，单位：天、时、分。
有时我们需要计算时间差，但是timedelta对象中只包含days、seconds、microseconds三种属性，并不能满足我们的需要，于是可以写一个函数，传入两个datetime对象，计算其天、时、分的差值：
def delta(start,end):
days = 0
hours = 0
minutes = 0
delta = end-start
minutes = int(delta.total_seconds() // 60)
if minutes >= 60:
hours = int(minutes // 60)
minutes = minutes - 60 * hours
if hours >= 24:
days = int(hours // 24)
hours = hours - 24 * days
text = str(days) + '天' if days else ''
text = text + str(hours) + '时' if hours else text
text = text + str(minutes) + '分' if minutes else text
return text
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
运行
效果：
dt1 = datetime(2021,1,1,9,30,20)
dt2 = datetime(2021,6,15,12,30,20)
print(delta(dt1,dt2)) #执行函数
- 1
- 2
- 3
>>>
=================== RESTART: D:\Python\Files\delta.py ==================
165天3时
- 1
- 2
- 3
1.5
import datetime as datet
from datetime import datetime, timedelta, timezone
- 1
- 2
运行
timezone类的参数：
| 参数 | 描述 |
|---|---|
| offset | timedelta类型，表示与UTC时区的时间间隔，范围：-timedelta(hours=24)至timedelta(hours=24) |
| name | 可选参数，字符串类型，设置该时区名称，可以被datetime对象通过实例方法tzname()获取 |
timezone类的属性：
| 属性 | 描述 |
|---|---|
| 表示utc时区，即timezone(timedelta(hours=0)) |
使用示例：
>>> import datetime as datet
>>> from datetime import datetime, timedelta, timezone
>>> datetime(2021,1,1,12,30,50,tzinfo=timezone.utc)
datetime.datetime(2021, 1, 1, 12, 30, 50, tzinfo=datetime.timezone.utc)
>>> datetime(2021,1,1,12,30,50,tzinfo=timezone(timedelta(hours=8)))
datetime.datetime(2021, 1, 1, 12, 30, 50, tzinfo=datetime.timezone(datetime.timedelta(seconds=28800))) #北京时间
>>> dt = datetime(2021,1,1,12,59,59,tzinfo=timezone.utc) #utc时区
>>> dt.tzinfo #获取时区信息
datetime.timezone.utc
>>> dt.tzname() #获取时区名称
'UTC'
>>> dt.utcoffset() #获取偏移量
datetime.timedelta(0)
>>> dt2 = datetime(2021,1,1,12,59,59,tzinfo=timezone(timedelta(hours=8),name='Beijing')) #自定义时区名称
>>> dt2.tzinfo #获取时区信息
datetime.timezone(datetime.timedelta(seconds=28800), 'Beijing')
>>> dt2.tzname() #获取时区名称
'Beijing'
>>> dt2.utcoffset() #获取偏移量
datetime.timedelta(seconds=28800)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
2. 模块内格式字符的含义一览表
| 字符 | 描述 |
|---|---|
| %a | 星期的简写，如星期三为Wed |
| %A | 星期的全写，如星期三为Wednesday |
| %b | 月份的简写，如4月为Apr |
| %B | 月份的全写，如4月为April |
| %c | 日期时间的字符串表示，如： 04/07/10 10:43:39 |
| %d | 日在这个月中的天数 |
| %f | 微秒（范围：0至999999） |
| %H | 小时（24小时制，范围：0至 23） |
| %I | 小时（12小时制，范围：0至 11） |
| %j | 日在年中的天数，范围：001至366 |
| %m | 月份，范围：01至12 |
| %M | 分钟，范围：00至59 |
| %p | AM或者PM |
| %S | 秒，范围：00至61 |
| %U | 周在当年的周数，星期天为周的第一天 |
| %w | 今天在这周的天数，范围：0至6，6表示星期天 |
| %W | 周在当年的周数，星期一作为周的第一天 |
| %x | 日期字符串，如：04/07/10 |
| %X | 时间字符串，如：10:43:39 |
| %y | 2位数表示的年份 |
| %Y | 4位数表示的年份 |
| %z | 与utc时间的间隔 （如果是本地时间，返回空字符串） |
| %Z | 时区名称（如果是本地时间，返回空字符串） |
| %% | 转义，%不变 |
结束语
datetime库功能全面，在其常用模块中，基本上只需要模块便能满足日常需求。
2021/8/1