time

UTC（Coordinated Universal Time，世界协调时）亦即格林威治天文时间，世界标准时间。在中国为 UTC+8。DST（Daylight Saving Time）即夏令时。

在 Python 中，与时间处理有关的模块就包括：time，datetime 以及 calendar

在开始之前，首先要说明这几点，在 Python 中，通常有这几种方式来表示时间：

• 时间戳 timestamp 时间

  通常来说，时间戳表示的是从 1970-1-1 00:00:00 开始按秒计算的偏移量。运行 time.time() ，返回的是 float 类型。时间戳是一个浮点数，可以进行加减运算，但请注意不要让结果超出取值范围。

• 格式化的时间字符串（str）时间

  格式化的时间字符串（string_time）：也就是年月日时分秒这样的我们常见的时间字符串，例如2023-10-01 09:12:48 ，可以通过time.strftime('%Y-%m-%d')获得;

• 元组（struct_time，共九个元素）。

  元组（struct_time ）方式，也可以叫做结构化时间，一个包含了年月日时分秒的多元元组，例如time.struct_time(tm_year=2017, tm_mon=9, tm_mday=26, tm_hour=9, tm_min=14, tm_sec=50, tm_wday=1, tm_yday=269, tm_isdst=0) ，可以通过time.localtime()获得。返回 struct_time 的函数主要有全球统一时间gmtime()，localtime()，strptime()。

提示

时间戳给电脑计算方便，结构化时间（元组）是给程序使用方便，字符串则是给普通人看的。

时间戳

时间戳（timestamp），一个能表示一份数据在某个特定时间之前已经存在的、 完整的、 可验证的数据,通常是一个字符序列，唯一地标识某一刻的时间。

.time()

返回当前系统时间戳。时间戳是一个数字可以做算术运算。

>>> import time
>>> time.time()
1683530884.3103604

该方法经常用于计算程序运行时间：

>>> # 打印时间戳
>>> print(time.time())
1683531013.4604592
>>> time.sleep(3)
>>> print(time.time())
1683531016.4699304

案例：时间戳的三种格式

>>> import time
>>> now_time = time.time()
>>> now_time  # 时间戳
1689842979.9890325
>>> int(now_time)  # 时间戳(10位)
1689842979
>>> int(now_time * 1000)  # 时间戳(13位)
1689842979989
>>> hex(int(now_time))  # 十六进制
0x64b8f523
>>> time.gmtime()  #  UTC 时区的结构化时间 .gmtime() （格林威治时间）
time.struct_time(tm_year=2023, tm_mon=7, tm_mday=20, tm_hour=8, tm_min=50, tm_sec=4, tm_wday=3, tm_yday=201, tm_isdst=0)
>>> 
>>> time.localtime()  # 本地的时间
time.struct_time(tm_year=2023, tm_mon=7, tm_mday=20, tm_hour=16, tm_min=50, tm_sec=9, tm_wday=3, tm_yday=201, tm_isdst=0)
>>> 
>>> time.ctime()  # 格式化字符串表示的当地时间
Thu Jul 20 16:50:12 2023

.sleep(t)

time 模块最常用的方法之一，用来睡眠或者暂停程序 t 秒，t 可以是浮点数或整数。

结构化时间

结构化时间（struct_time）对象，是 python 语言操作时的对象。

本地时间

本地时间 .localtime([secs])。使用 time.localtime() 等方法可以获得一个结构化时间元组。secs 参数未提供时，则以当前时间为准。

>>> time.localtime()
time.struct_time(tm_year=2023, tm_mon=5, tm_mday=8, tm_hour=15, tm_min=30, tm_sec=35, tm_wday=0, tm_yday=128, tm_isdst=0)
>>> time.localtime(1683531016.4699304)
time.struct_time(tm_year=2023, tm_mon=5, tm_mday=8, tm_hour=15, tm_min=30, tm_sec=16, tm_wday=0, tm_yday=128, tm_isdst=0)

结构化时间元组共有 9 个元素，按顺序排列如下表：

索引（Index）	属性（Attribute）	值（Values）
0	tm_year（年）	比如2011
1	tm_mon（月）	1 - 12
2	tm_mday（日）	1 - 31
3	tm_hour（时）	0 - 23
4	tm_min（分）	0 - 59
5	tm_sec（秒）	0 - 61（包含闰秒和双闰秒）
6	tm_wday（weekday）	0 - 6（0表示周一）
7	tm_yday（一年中的第几天）	1 - 366
8	tm_isdst（是否是夏令时）	默认为-1,0,1

既然结构化时间是一个元组，那么就可以通过索引进行取值，也可以进行分片，或者通过属性名获取对应的值。

>>> lt = time.localtime()
>>> lt
time.struct_time(tm_year=2023, tm_mon=5, tm_mday=8, tm_hour=15, tm_min=31, tm_sec=22, tm_wday=0, tm_yday=128, tm_isdst=0)
>>> lt[3]
15
>>> lt[2:5]
(8, 15, 31)

但是要记住，Python 的 struct_time 类型是不可变类型，所有的时间值都只读，不能改！！

>>> lt.tm_wday = 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: readonly attribute

UTC 时间

UTC 时间 .gmtime([secs])，将一个时间戳转换为 UTC 时区的结构化时间。可选参数 secs 的默认值为time.time()。

>>> time.gmtime()
time.struct_time(tm_year=2023, tm_mon=5, tm_mday=8, tm_hour=7, tm_min=33, tm_sec=25, tm_wday=0, tm_yday=128, tm_isdst=0)
>>> t = time.time() - 10000
>>> time.gmtime(t)
time.struct_time(tm_year=2023, tm_mon=5, tm_mday=8, tm_hour=4, tm_min=46, tm_sec=52, tm_wday=0, tm_yday=128, tm_isdst=0)

结构化时间转时间戳

结构化时间转化为时间戳 .mktime(t)。将一个结构化时间转化为时间戳。time.mktime()执行与gmtime(),localtime() 相反的操作，它接收struct_time 对象作为参数,返回用秒数表示时间的浮点数。如果输入的值不是一个合法的时间，将触发OverflowError或ValueError。

>>> time.mktime(time.localtime())
1683531378.0

>>> time.mktime(1683531016)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Tuple or struct_time argument required

案例：结构化时间

>>> import time
>>> local_time = time.localtime()  # 打印当地时间格式化时间
>>> local_time
time.struct_time(tm_year=2023, tm_mon=7, tm_mday=20, tm_hour=16, tm_min=54, tm_sec=52, tm_wday=3, tm_yday=201, tm_isdst=0)
>>> # 获取年-月-日
>>> local_time.tm_year, local_time.tm_mon, local_time.tm_mday
(2023, 7, 20)
>>> # gmtime 将 时间戳 转化为 struct_time
>>> time.gmtime(time.time())
time.struct_time(tm_year=2023, tm_mon=7, tm_mday=20, tm_hour=8, tm_min=55, tm_sec=30, tm_wday=3, tm_yday=201, tm_isdst=0)
>>> # mktime 将 struct_time 转化为 时间戳
>>> time.mktime(local_time)
1689843292.0

字符串

字符串常用于输出给人看。

本地时间

本地时间 .ctime([secs])。把一个时间戳转化为本地时间的格式化字符串。默认使用time.time()作为参数。

>>> time.ctime()
'Mon May  8 15:36:37 2023'
>>> time.ctime(time.time())
'Mon May  8 15:36:43 2023'
>>> time.ctime(1683531016)
'Mon May  8 15:30:16 2023'
>>> time.ctime(time.time() + 10000)
'Mon May  8 18:23:41 2023

结构化时间对象转字符串

.strftime(format [, t])，返回格式化字符串表示的当地时间。把一个struct_time（如time.localtime()和time.gmtime() 的返回值）转化为格式化的时间字符串，显示的格式由参数format决定。如果未指定 t，默认传入time.localtime() 。如果元组中任何一个元素越界，就会抛出ValueError的异常。

>>> time.strftime("%Y-%m-%d %H:%M:%S")
'2023-05-08 15:37:18'
>>> time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime())
'2023-05-08 07:37:23'

字符串转结构化时间对象

.strptime(string[,format])，将格式化时间字符串转化成结构化时间。该方法是time.strftime()方法的逆操作。time.strptime() 方法根据指定的格式把一个时间字符串解析为时间元组。要注意的是，你提供的字符串要和 format 参数的格式一一对应，如果 string 中日期间使用 - 分隔，format 中也必须使用 - 分隔，时间中使用冒号 : 分隔，后面也必须使用冒号分隔，否则会报格式不匹配的错误。并且值也要在合法的区间范围内，千万不要整出 14 个月来。

>>> stime = "2023-05-08 12:11:30"
>>> st = time.strptime(stime, "%Y-%m-%d %H:%M:%S")
>>> st
time.struct_time(tm_year=2023, tm_mon=5, tm_mday=8, tm_hour=12, tm_min=11, tm_sec=30, tm_wday=0, tm_yday=128, tm_isdst=-1)
>>> for item in st:
...     print(item)
...
2023
5
8
12
11
30
0
128
-1

>>> wrong_time = "2022-14-26 12:11:30"
>>> st = time.strptime(wrong_time, "%Y-%m-%d %H:%M:%S")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "D:\Python310\lib\_strptime.py", line 562, in _strptime_time
    tt = _strptime(data_string, format)[0]
  File "D:\Python310\lib\_strptime.py", line 349, in _strptime
    raise ValueError("time data %r does not match format %r" %
ValueError: time data '2022-14-26 12:11:30' does not match format '%Y-%m-%d %H:%M:%S'

格式化时间字符串

利用 time.strftime('%Y-%m-%d %H:%M:%S') 等方法可以获得一个格式化时间字符串。

>>> time.strftime('%Y-%m-%d %H:%M:%S')
'2023-05-08 15:40:01'

注意其中的空格、短横线和冒号都是美观修饰符号，真正起控制作用的是百分符。对于格式化控制字符串 "%Y-%m-%d %H:%M:%S ，其中每一个字母所代表的意思如下表所示，注意大小写的区别：

格式	含义
%a	本地星期名称的简写（如星期四为Thu）
%A	本地星期名称的全称（如星期四为Thursday）
%b	本地月份名称的简写（如八月份为agu）
%B	本地月份名称的全称（如八月份为august）
%c	本地相应的日期和时间的字符串表示（如：15/08/27 10:20:06）
%d	一个月中的第几天（01 - 31）
%f	微秒（范围0.999999）
%H	一天中的第几个小时（24小时制，00 - 23）
%I	第几个小时（12小时制，0 - 11）
%j	一年中的第几天（001 - 366）
%m	月份（01 - 12）
%M	分钟数（00 - 59）
%p	本地am或者pm的标识符
%S	秒（00 - 61）
%U	一年中的星期数。（00 - 53星期天是一个星期的开始。）第一个星期天之 前的所有天数都放在第0周。
%w	一个星期中的第几天（0 - 6，0是星期天）
%W	和%U基本相同，不同的是%W以星期一为一个星期的开始。
%x	本地相应日期字符串（如15/08/01）
%X	本地相应时间字符串（如08:08:10）
%y	去掉世纪的年份（00 - 99）两个数字表示的年份
%Y	完整的年份（4个数字表示年份）
%z	与UTC时间的间隔（如果是本地时间，返回空字符串）
%Z	时区的名字（如果是本地时间，返回空字符串）
%%	‘%’字符

案例：字符串时间

>>> import time
>>> time.ctime()  # 字符串表示的当地时间
'Thu Jul 20 16:58:50 2023'

>>> # 将 struct_time 转化为 字符串 
>>> # strptime('时间字符串','格式化字符串')
>>> time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())
'2023-07-20 16:59:03'

>>> # 将字符串 转化为 struct_time
>>> time.strptime('2019-08-07 04:36:15', '%Y-%m-%d %H:%M:%S')
time.struct_time(tm_year=2019, tm_mon=8, tm_mday=7, tm_hour=4, tm_min=36, tm_sec=15, tm_wday=2, tm_yday=219, tm_isdst=-1)

时间格式之间的转换

Python 的三种类型时间格式，可以互相进行转换，如下图和下表所示：

从	到	方法
时间戳	UTC结构化时间	gmtime()
时间戳	本地结构化时间	localtime()
UTC结构化时间	时间戳	calendar.timegm()
本地结构化时间	时间戳	mktime()
结构化时间	格式化字符串	strftime()
格式化字符串	结构化时间	strptime()

>>> import time

>>> """时间戳转结构化时间"""
>>> # 时间戳转 struct_time
>>> print(time.localtime(1515113337))
time.struct_time(tm_year=2018, tm_mon=1, tm_mday=5, tm_hour=8, tm_min=48, tm_sec=57, tm_wday=4, tm_yday=5, tm_isdst=0)
>>> #  UTC 时区的结构化时间 .gmtime()
>>> print(time.ctime())
Thu Jul 20 18:35:18 2023

>>> """结构化时间转时间戳"""
>>> # 将 struct_time 转 时间戳
>>> struct_time = time.localtime()
>>> print(time.mktime(struct_time))
1689849324.0

>>> """时间戳转字符串"""
>>> # 格式化字符串表示的当地时间
>>> print(time.ctime())
Thu Jul 20 18:35:31 2023

>>> # 将时间输出为字符串
>>> print(time.strftime('%Y-%m-%d %H:%M:%S', struct_time))
2023-07-20 18:35:24

>>> # 将字符串转化为 struct_time
>>> print(time.strptime('2019-08-07 04:36:15', '%Y-%m-%d %H:%M:%S'))
time.struct_time(tm_year=2019, tm_mon=8, tm_mday=7, tm_hour=4, tm_min=36, tm_sec=15, tm_wday=2, tm_yday=219, tm_isdst=-1)

案例

案例-计算时间差:

1. 将 '1997-10-10' 格式化为 struct_time 时间

2. 将 struct_time 时间变为字符串时间

3. 将 struct_time 时间变为时间戳

4. 将 时间戳 变为 struct_time 时间

参考答案

import time

print(time.strptime('1997-10-01', '%Y-%m-%d'))

print(time.strftime('%Y-%m-%d', time.strptime('1997-10-01', '%Y-%m-%d')))

print(time.mktime(time.strptime('1997-10-01', '%Y-%m-%d')))

print(time.gmtime(time.time()))