Python | time和datetime模块详解
对时间进行处理
python与时间处理相关的模块有两个： time模块和datetime模块（python的内置标准库，不需要去下载）
datetime模块， 常用类4个(date, time, datetime, timedelta)
概念：
- 在Python中，通常有这几种方式表示时间：时间戳、格式化的时间字符串、元组（struct_time 共九种元素）。由于Python的time模块主要是调用C库实现的，所以在不同的平台可能会有所不同。
- 时间戳（timestamp）的方式：时间戳表示是从1970年1月1号 00:00:00开始到现在按秒计算的偏移量。查看一下type(time.time())的返回值类型，可以看出是float类型。返回时间戳的函数主要有time()、clock()等。
- UTC（世界协调时），就是格林威治天文时间，也是世界标准时间。在中国为UTC+8。DST夏令时。
- 元组方式：struct_time元组共有9个元素，返回struct_time的函数主要有gmtime()，localtime()，strptime()
一、time模块
time模块中时间表现的格式主要有三种：
a、timestamp时间戳，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量
b、struct_time时间元组，共有九个元素组。
c、format time 格式化时间，已格式化的结构使时间更具可读性。包括自定义格式和固定格式。
time模块中常用的函数
使用该模块中的函数时，必须先引入该模块（import time）
1、time.time()：返回当前时间的时间戳
实例：
import time
ls = time.time()
print(ls)
#输出结果
1646034067.319167
2、time.localtime( [secs] )
将一个时间戳转换为当前时区的struct_time，即时间数组格式的时间 ；
参数：
- sec – 转换为time.struct_time类型的对象的秒数
如果secs参数未提供，则以当前时间为准（即会默认调用time.time()）。
实例：
import time
ls = time.localtime()
ls_1 = time.localtime(1646037618.0)
print(ls)
print(ls[0])
print(ls.tm_year)
#输出结果
time.struct_time(tm_year=2022, tm_mon=2, tm_mday=28, tm_hour=15, tm_min=28, tm_sec=56, tm_wday=0, tm_yday=59, tm_isdst=0)
time.struct_time(tm_year=2022, tm_mon=2, tm_mday=28, tm_hour=16, tm_min=40, tm_sec=18, tm_wday=0, tm_yday=59, tm_isdst=0)
2022
2022
3、time.gmtime([secs])
将一个时间戳转换为UTC时区的struct_time
time.gmtime() 函数将一个时间戳转换为UTC时区（0时区）的struct_time，可选的参数sec表示从1970-1-1 00:00:00以来的秒数。其默认值为time.time()，函数返回time.struct_time类型的对象。（struct_time是在time模块中定义的表示时间的对象）。
如果secs参数未提供，则以当前时间为准。
参数：
- sec – 转换为time.struct_time类型的对象的秒数
实例：
import time
ls = time.gmtime()
print(ls)
#输出结果
time.struct_time(tm_year=2022, tm_mon=2, tm_mday=28, tm_hour=8, tm_min=26, tm_sec=16, tm_wday=0, tm_yday=59, tm_isdst=0)
4、time.mktime(t)：将一个struct_time转化为时间戳
time.mktime() 函数执行与gmtime(), localtime()相反的操作，它接收struct_time对象作为参数,返回用秒数表示时间的浮点数。
如果输入的值不是一个合法的时间，将触发 OverflowError 或 ValueError。
参数：
- t – 结构化的时间或者完整的9位元组元素
实例：
import time
ls = time.mktime(time.localtime())
ls_1 = time.mktime((2022,2,28,16,40,18,0,59,0))
print(ls,ls_1)
#输出结果
1646037990.0
1646037618.0
5、time.sleep(secs)：线程推迟指定的时间运行
线程睡眠指定时间，单位为妙。
>>> time.sleep(10)
6、time.clock()
这个函数， 函数以浮点数计算的秒数返回当前的CPU时间。用来衡量不同程序的耗时，比time.time()更有用。
Python 3.8 已移除 clock() 方法， 可以使用 time.perf_counter() 或 time.process_time() 方法替代。
（1）time.perf_counter()
返回性能计数器的值（以小数秒为单位）作为浮点数，即具有最高可用分辨率的时钟，以测量短持续时间。 它确实包括睡眠期间经过的时间，并且是系统范围的。
通常perf_counter()用在测试代码时间上，具有最高的可用分辨率。不过因为返回值的参考点未定义，因此我们测试代码的时候需要调用两次，做差值。
perf_counter()会包含sleep()休眠时间，适用测量短持续时间
实例：
import time
start = time.perf_counter()
time.sleep(2)
end = time.perf_counter()
print(end-start)
#输出结果
-1.999896384
（2）time.process_time()
返回当前进程的系统和用户CPU时间总和的值（以小数秒为单位）作为浮点数。
通常time.process_time()也用在测试代码时间上，根据定义，它在整个过程中。返回值的参考点未定义，因此我们测试代码的时候需要调用两次，做差值。
注意process_time()不包括sleep()休眠时间期间经过的时间。
实例：
import time
start = time.process_time()
time.sleep(2)
end = time.process_time()
print(end-start)
#输出结果
0.0
此外Python3.7开始还提供了以上三个方法精确到纳秒的计时。分别是：
time.perf_counter_ns()
time.process_time_ns()
time.time_ns()
注意这三个精确到纳秒的方法返回的是整数类型。
7、time.asctime( [t] )
把一个表示时间的元组或者struct_time表示为 ‘Sun Aug 23 14:31:59 2015’ 这种形式。如果没有给参数，会将time.localtime()作为参数传入。
参数：
- t – 9个元素的元组或者通过函数 gmtime() 或 localtime() 返回的时间值
实例：
import time
ls = time.asctime()
ls_1 = time.asctime(time.gmtime())
print(ls,ls_1)
#输出结果
Mon Feb 28 18:00:21 2022
Mon Feb 28 10:00:21 2022
8、time.ctime([secs])
把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果为指定参数，将会默认使用time.time()作为参数。它的作用相当于time.asctime(time.localtime(secs))
参数：
- sec – 要转换为字符串时间的秒数
实例：
import time
ls = time.time()
ls_1 = time.ctime(ls)
ls_2 = time.ctime(1646042629.259167)
print(ls,ls_1,ls_2)
#输出结果
1646042649.472167
Mon Feb 28 18:04:09 2022
Mon Feb 28 18:03:49 2022
9、time.strftime( format [, t] )
返回字符串表示的当地时间。
把一个代表时间的元组或者struct_time（如由time.localtime()和time.gmtime()返回）转化为格式化的时间字符串，格式由参数format决定。如果未指定，将传入time.localtime()。如果元组中任何一个元素越界，就会抛出ValueError的异常。函数返回的是一个可读表示的本地时间的字符串。
参数：
- format：格式化字符串
- t ：可选的参数是一个struct_time对象
时间字符串支持的格式符号：（区分大小写）
- %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
ls = time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())
print(ls)
#输出结果
2022-03-01 14:30:05
import time
a = (2022,3,1,14,30,30,0,0,0)
ls = time.strftime("%Y-%m-%d %H:%M:%S",a)
print(ls)
#输出结果
2022-03-01 14:30:30
获取当前时间
import time
ls = time.strftime("%Y-%m-%d %H:%M:%S")
print(ls)
#输出结果
2022-03-01 14:35:30
10、time.strptime(string[,format])
将格式字符串转化成struct_time.
该函数是time.strftime()函数的逆操作。time strptime() 函数根据指定的格式把一个时间字符串解析为时间元组。所以函数返回的是struct_time对象。
参数：
- string ：时间字符串
- format：格式化字符串
创建一个时间字符串变量stime，
通过strptime()函数将stime转化成strcut_time形式
实例：
import time
stime = "2015-08-24 13:01:30"
ls = time.strptime(stime,"%Y-%m-%d %H:%M:%S")
print(ls) #输出结果
time.struct_time(tm_year=2015, tm_mon=8, tm_mday=24, tm_hour=13, tm_min=1, tm_sec=30, tm_wday=0, tm_yday=236, tm_isdst=-1)
注意：在使用strptime()函数将一个指定格式的时间字符串转化成元组时，参数format的格式必须和string的格式保持一致，如果string中日期间使用“-”分隔，format中也必须使用“-”分隔，时间中使用冒号“:”分隔，后面也必须使用冒号分隔，否则会报格式不匹配的错误。
二、datetime模块
datatime模块重新封装了time模块，提供更多接口，
提供的类有：date,time,datetime,timedelta,tzinfo
datetime模块定义了5个类，分别是
1.datetime.date：表示日期的类
2.datetime.datetime：表示日期时间的类
3.datetime.time：表示时间的类
4.datetime.timedelta：表示时间间隔，即两个时间点的间隔
5.datetime.tzinfo：时区的相关信息
from datetime import date
from datetime import datetime
from datetime import time
from datetime import timedelta
from datetime import tzinfo
1、datetime.date类：
date类有三个参数，datetime.date(year,month,day)，返回year-month-day。
静态方法和字段：
date.max、date.min：date对象所能表示的最大、最小日期；
date.resolution：date对象表示日期的最小单位。这里是天。
date.today()：返回一个表示当前本地日期的date对象；
date.fromtimestamp(timestamp)：根据给定的时间戮，返回一个date对象；
from datetime import *
import time
print('date.max:', date.max)
print('date.min:', date.min)
print('date.today():', date.today())
print('date.fromtimestamp():', date.fromtimestamp(time.time()))
#Output==============
# date.max: 9999-03-01
# date.min: 0001-03-01
# date.today(): 2022-03-01
# date.fromtimestamp(): 2020-03-01
在date前加datetime效果一样~
方法和属性：
d1 = date(2011,06,03) #date对象
d1.year、date.month、date.day：年、月、日；
d1.replace(year, month, day)：生成一个新的日期对象，用参数指定的年，月，日代替原有对象中的属性。（原有对象仍保持不变）
d1.timetuple()：返回日期对应的time，struct_time对象；
d1.weekday()：返回weekday，如果是星期一，返回0；如果是星期2，返回1，以此类推；
d1.isoweekday()：返回weekday，如果是星期一，返回1；如果是星期2，返回2，以此类推；
d1.isocalendar()：返回格式如(year，month，day)的元组；
d1.isoformat()：返回格式如'YYYY-MM-DD’的字符串；
d1.strftime(fmt)：和time模块format相同。
d1.ctime()：返回格式如 Sun Apr 16 00:00:00 2021
from datetime import *
now = date(2016, 10, 26)
tomorrow = now.replace(day = 27)
print('now:', now, ', tomorrow:', tomorrow)
print('timetuple():', now.timetuple())
print('weekday():', now.weekday())
print('isoweekday():', now.isoweekday())
print('isocalendar():', now.isocalendar())
print('isoformat():', now.isoformat())
print('strftime():', now.strftime("%Y-%m-%d"))
print('ctime()：'d1.ctime())
#Output========================
# now: 2016-10-26 , tomorrow: 2016-10-27
# timetuple(): time.struct_time(tm_year=2016, tm_mon=10, tm_mday=26, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=300, tm_isdst=-1)
# weekday(): 2
# isoweekday(): 3
# isocalendar(): (2016, 43, 3)
# isoformat(): 2016-10-26
# strftime(): 2016-10-26
# ctime()：Wed Oct 26 00:00:00 2016
二、看一下datetime的time类
time类有5个参数，datetime.time(hour,minute,second,microsecond,tzoninfo),返回08:29:30
datetime.time
import datetime
ls = datetime.time(22,12,13,10)
print(ls)
#输出结果
22:12:13.000010
静态方法和字段：
time.min、time.max：time类所能表示的最小、最大时间。其中，time.min = time(0, 0, 0, 0)， time.max = time(23, 59, 59, 999999)；
time.resolution：时间的最小单位，这里是1微秒；
print(datetime.time.min)
00:00:00
t1 = datetime.time(10,23,15) #time对象
t1.hour、t1.minute、t1.second、t1.microsecond：时、分、秒、微秒；
t1.tzinfo：时区信息；
t1.replace([ hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] )：创建一个新的时间对象，用参数指定的时、分、秒、微秒代替原有对象中的属性（原有对象仍保持不变）；
t1.isoformat()：返回型如"HH:MM:SS"格式的字符串表示；
t1.strftime(fmt)：同time模块中的format；
t1.tzname()：返回时区名字；
t1.utcoffset()：返回时区的时间偏移量
from datetime import *
tm = time(23, 46, 10)
print('tm:', tm)
print('hour: %d, minute: %d, second: %d, microsecond: %d' % (tm.hour, tm.minute, tm.second, tm.microsecond))
tm1 = tm.replace(hour=20)
print('tm1:', tm1)
print('isoformat():', tm.isoformat())
print('strftime()', tm.strftime("%X"))
#Output==============================================
# tm: 23:46:10
# hour: 23, minute: 46, second: 10, microsecond: 0
# tm1: 20:46:10
# isoformat(): 23:46:10
# strftime() 23:46:10
三、datetime的datetime类
datetime类有很多参数，datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])，返回年月日，时分秒
静态方法和字段：
- datetime.today()：返回一个表示当前本地时间的datetime对象；
- datetime.now([tz])：返回一个表示当前本地时间的datetime对象，如果提供了参数tz，则获取tz参数所指时区的本地时间；
- datetime.utcnow()：返回一个当前utc时间的datetime对象；#格林威治时间
- datetime.fromtimestamp(timestamp[, tz])：根据时间戮创建一个datetime对象，参数tz指定时区信息；
- datetime.utcfromtimestamp(timestamp)：根据时间戮创建一个datetime对象；
- datetime.combine(date, time)：根据date和time，创建一个datetime对象；
- datetime.strptime(date_string, format)：将格式字符串转换为datetime对象；
from datetime import *
import time
print('datetime.max:', datetime.max)
print('datetime.min:', datetime.min)
print('datetime.resolution:', datetime.resolution)
print('today():', datetime.today())
print('now():', datetime.now())
print('utcnow():', datetime.utcnow())
print('fromtimestamp(tmstmp):', datetime.fromtimestamp(time.time()))
print('utcfromtimestamp(tmstmp):', datetime.utcfromtimestamp(time.time()))
#output======================
# datetime.max: 9999-12-31 23:59:59.999999
# datetime.min: 0001-01-01 00:00:00
# datetime.resolution: 0:00:00.000001
# today(): 2016-10-26 23:12:51.307000
# now(): 2016-10-26 23:12:51.307000
# utcnow(): 2016-10-26 15:12:51.307000
# fromtimestamp(tmstmp): 2016-10-26 23:12:51.307000
# utcfromtimestamp(tmstmp): 2016-10-26 15:12:51.307000
方法和属性：
dt=datetime.now()#datetime对象
dt.year、month、day、hour、minute、second、microsecond、tzinfo：
dt.date()：获取date对象；
dt.time()：获取time对象；
dt. replace ([ year[ , month[ , day[ , hour[ , minute[ , second[ , microsecond[ , tzinfo] ] ] ] ] ] ] ])：
dt. timetuple ()
dt. utctimetuple ()
dt. toordinal ()
dt. weekday ()
dt. isocalendar ()
dt. isoformat ([ sep] )
dt. ctime ()：返回一个日期时间的C格式字符串，等效于time.ctime(time.mktime(dt.timetuple()))；
dt. strftime (format)
【【【
datetime.datetime.ctime() 将datetime.datetime类型转化成str类型
print(datetime.datetime.now().ctime())
Tue Mar 1 23:00:31 2022
datetime.datetime.now()：返回当前系统时间
print(datetime.datetime.now())
2022-03-01 22:49:51.087872
datetime.datetime.now().date()：返回当前日期时间的日期部分
print(datetime.datetime.now().date())
2022-03-01
datetime.datetime.now().time()：返回当前日期时间的时间部分
print(datetime.datetime.now().time())
22:55:36.096962
datetime.datetime.strftime()：由日期格式转化为字符串格式
datetime.datetime.now().strftime('%b-%d-%Y %H:%M:%S')
'Apr-16-2017 21:01:35'
datetime.datetime.strptime():由字符串格式转化为日期格式
datetime.datetime.strptime('Apr-16-2017 21:01:35', '%b-%d-%Y %H:%M:%S')
2017-04-16 21:01:35
】】】
四、datetime的timedelta类
datetime.timedelta用来计算两个datetime.datetime或者datetime.date类型之间的时间差。
def __new__(cls, days=0, seconds=0, microseconds=0,milliseconds=0, minutes=0, hours=0, weeks=0):
从构造函数中来看，参数可选：days、seconds、microseconds、milliseconds、minutes、hours、weeks，且默认是0。
实例：
1. 查询300天前是几月几号
import datetime
now = datetime.datetime.now().date()
delta = datetime.timedelta(days = 300)
print(now - delta)
#输出结果
2021-05-07
2. datetime.timedelta()也可以多个参数，比如计算300天12小时前的时间
import datetime
now = datetime.datetime.now()
delta = datetime.timedelta(days = 300,hours = 12)
print(now - delta)
#输出结果
2021-05-06 23:51:36.405974
3. 计算总天数和秒数
>>> datetime.timedelta(days=1,hours = 2).days 1 >>> datetime.timedelta(days=1,hours = 2).total_seconds() 93600.0
5、tzinfo时区类
#! /usr/bin/python
# coding=utf-8
from datetime import datetime, tzinfo,timedelta
"""
tzinfo是关于时区信息的类
tzinfo是一个抽象类，所以不能直接被实例化
"""
class UTC(tzinfo):
"""UTC"""
def __init__(self,offset = 0):
self._offset = offset
def utcoffset(self, dt):
return timedelta(hours=self._offset)
def tzname(self, dt):
return "UTC +%s" % self._offset
def dst(self, dt):
return timedelta(hours=self._offset)
#北京时间
beijing = datetime(2011,11,11,0,0,0,tzinfo = UTC(8))
print "beijing time:",beijing
#曼谷时间
bangkok = datetime(2011,11,11,0,0,0,tzinfo = UTC(7))
print "bangkok time",bangkok
#北京时间转成曼谷时间
print "beijing-time to bangkok-time:",beijing.astimezone(UTC(7))
#计算时间差时也会考虑时区的问题
timespan = beijing - bangkok
print "时差:",timespan
#Output==================
# beijing time: 2011-11-11 00:00:00+08:00
# bangkok time 2011-11-11 00:00:00+07:00
# beijing-time to bangkok-time: 2011-11-10 23:00:00+07:00
# 时差: -1 day, 23:00:00
