Python之时间模块

时间模块

相关术语的解释

• UTC time Coordinated Universal Time，世界协调时，又称 格林尼治天文时间、世界标准时间。与UTC time对应的是各个时区的local time，东N区的时间比UTC时间早N个小时，因此UTC time + N小时 即为东N区的本地时间；而西N区时间比UTC时间晚N个小时，即 UTC time - N小时 即为西N区的本地时间； 中国在东8区，因此比UTC时间早8小时，可以以UTC+8进行表示。

• epoch time 表示时间开始的起点；它是一个特定的时间，不同平台上这个时间点的值不太相同，对于Unix而言，epoch time为 1970-01-01 00:00:00 UTC。

• timestamp（时间戳） 也称为Unix时间 或 POSIX时间；它是一种时间表示方式，表示从格林尼治时间1970年1月1日0时0分0秒开始到现在所经过的毫秒数，其值为float类型。 但是有些编程语言的相关方法返回的是秒数（Python就是这样），这个需要看方法的文档说明。需要说明的是时间戳是个差值，其值与时区无关。

一、 time 模块

　　导入： import time 

　　时间的三种表示方法：时间戳，格式化的时间字符串，元组形式

　(1)时间戳(Timestamp) ：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。

import time

print(time.time())  # ---时间戳，计算，标识一个唯一的时间
print(type(time.time()))    # 返回的是float类型

# 结果：
# 1537431504.1229575
# <class 'float'>

　

(2)格式化的时间字符串(Format String)字符串时间： ‘1999-12-06’。格式化时间 Format String

import time

print(time.strftime("%Y-%m-%d %H-%m-%s"))  # 时间字符串（人性化的时间表示）

　　python中时间日期格式化符号：

%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 当前时区的名称
%% %号本身

(3) 元组(struct_time)结构化时间 ：
　　struct_time元组共有九个元素: (年，月，日，时，分，秒，一年中第几周，一年中第几天等）

　　　　0 tm_year 年份，如 2017
　　　　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 一个星期中的第几天，取值范围为[0-6]，0表示星期一
　　　　7 tm_yday 一年中的第几天，取值范围为[1, 366]
　　　　8 tm_isdst 是否为夏令时，可取值为：0 , 1 或 -1

　　需要说明的是struct_time实例的各个属性都是只读的，不可修改。

import time

print(time.localtime())  #-时间元组（用来计算）

# 结果：
# time.struct_time(tm_year=2017, tm_mon=9, tm_mday=13,tm_hour=15, tm_min=58, tm_sec=6, tm_wday=2, tm_yday=256, tm_isdst=0)

小结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的

常用的time模块下的方法

time.altzone     # 返回与utc时间的时间差，以秒为单位（西区该值为正，东区该值为负）。其表示的是本地DST 时区的偏移量，只有daylight非0时才使用。
time.clock()     # 返回当前进程所消耗的处理器运行时间秒数（不包括sleep时间），值为小数；该方法Python3.3改成了time.process_time()
time.asctime([t])     # 将一个tuple或struct_time形式的时间（可以通过gmtime()和localtime()方法获取）转换为一个24个字符的时间字符串，格式为: "Fri Aug 19 11:14:16 2016"。如果参数t未提供，则取localtime()的返回值作为参数。
time.ctime([secs])     # 功能同上，将一个秒数时间戳表示的时间转换为一个表示当前本地时间的字符串。如果参数secs没有提供或值为None，则取time()方法的返回值作为默认值。ctime(secs)等价于asctime(localtime(secs))
time.time()     # 返回时间戳（自1970-1-1 0:00:00 至今所经历的秒数）
time.localtime([secs])     # 返回以指定时间戳对应的本地时间的 struct_time对象（可以通过下标，也可以通过 .属性名 的方式来引用内部属性）格式
time.localtime(time.time() + n*3600)     # 返回n个小时后本地时间的 struct_time对象格式（可以用来实现类似crontab的功能）
time.gmtime([secs])     # 返回指定时间戳对应的utc时间的 struct_time对象格式（与当前本地时间差8个小时）
time.gmtime(time.time() + n*3600)     # 返回n个小时后utc时间的 struct_time对象（可以通过 .属性名 的方式来引用内部属性）格式
time.strptime(time_str, time_format_str)     # 将时间字符串转换为struct_time时间对象，如：time.strptime('2017-01-13 17:07', '%Y-%m-%d %H:%M')
time.mktime(struct_time_instance)     # 将struct_time对象实例转换成时间戳
time.strftime(time_format_str, struct_time_instance)     # 将struct_time对象实例转换成字符串

　　

(4)三种格式之间的转换：
　　图示：

    元组(struct_time)--(strftime)-->格式化的时间字符串(Format String)

# time.strftime("格式定义", "结构化时间")
# 结构化时间参数若不传，则现实当前时间（将元组形式时间转为格式化的字符串时间）
import time

print(time.strftime("%Y-%m-%d %X"))
# 结果：2018-09-20 16:30:49
print(time.strftime("%Y-%m-%d", time.localtime(1500000000)))
# 结果：2017-07-14

    格式化的时间字符串(Format String)--(strptime)-->元组(struct_time)

# time.strptime(时间字符串, 字符串对应格式)
# 将格式化的时间字符串转换为元组形式时间
import time

print(time.strptime("2018-09-20", "%Y-%m-%d"))
# 结果：time.struct_time(tm_year=2018, tm_mon=9, tm_mday=20, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=263, tm_isdst=-1)
print(time.strptime("09/20/2018", "%m/%d/%Y"))
# 结果：time.struct_time(tm_year=2018, tm_mon=9, tm_mday=20, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=263, tm_isdst=-1)

 　　
　　元组(struct_time)--(mktime)-->时间戳(timestamp)

# time.gmtime(时间戳)  # UTC时间，与英国伦敦当地时间一致
# time.localtime(时间戳)  # 当地时间。例如我们现在在北京执行这个方法：与UTC时间相差8小时，UTC时间+8小时 = 北京时间
import time

print(time.gmtime(1537460000))
# 结果： time.struct_time(tm_year=2018, tm_mon=9, tm_mday=20, tm_hour=16, tm_min=13, tm_sec=20, tm_wday=3, tm_yday=263, tm_isdst=0)
print(time.localtime(1537460000))
# 结果： time.struct_time(tm_year=2018, tm_mon=9, tm_mday=20, tm_hour=16, tm_min=13, tm_sec=20, tm_wday=3, tm_yday=263, tm_isdst=0)

　　时间戳(timestamp)--(localtime/gmtime)-->元组(struct_time)

# time.mktime(结构化时间)
import time

time_tuple = time.localtime(1537460000)
print(time.mktime(time_tuple))
# 结果：1537460000.0　

　　

　　计算时间差

import time
true_time=time.mktime(time.strptime('2018-09-20 08:30:00','%Y-%m-%d %H:%M:%S'))
time_now=time.mktime(time.strptime('2018-09-20 16:41:00','%Y-%m-%d %H:%M:%S'))
dif_time=time_now-true_time
struct_time=time.gmtime(dif_time)
print('过去了%d年%d月%d天%d小时%d分钟%d秒'%(struct_time.tm_year-1970,struct_time.tm_mon-1,
                                       struct_time.tm_mday-1,struct_time.tm_hour,
                                       struct_time.tm_min,struct_time.tm_sec))

# 结果：
# 过去了0年0月0天8小时11分钟0秒

二、datetime 模块

　　datetime模块提供了处理日期和时间的类，既有简单的方式，又有复杂的方式。它虽然支持日期和时间算法，但其实现的重点是为输出格式化和操作提供高效的属性提取功能。

　　（1）datetime模块中定义的类：

datetime.date     # 表示日期，常用的属性有：year, month和day
datetime.time     # 表示时间，常用属性有：hour, minute, second, microsecond
datetime.datetime     # 表示日期时间
datetime.timedelta     # 表示两个date、time、datetime实例之间的时间间隔，分辨率（最小单位）可达到微秒
datetime.tzinfo     # 时区相关信息对象的抽象基类。它们由datetime和time类使用，以提供自定义时间的而调整。
datetime.timezone     # Python 3.2中新增的功能，实现tzinfo抽象基类的类，表示与UTC的固定偏移量

需要说明的是：这些类的对象都是不可变的。

　　

　　（2） datetime模块中定义的常量

　　　　datetime.MINYEAR    ->    datetime.date或datetime.datetime对象所允许的年份的最小值，值为1
　　　　datetime.MAXYEAR   ->    datetime.date或datetime.datetime对象所允许的年份的最大值，只为9999

　　

　　（3）datetime.date类

　　 　　datetime.date类的定义：

class datetime.date(year, month, day)

# year, month 和 day都是是必须参数，各参数的取值范围为：
year     # [MINYEAR, MAXYEAR]
month     # [1, 12]
day     # [1, 指定年份的月份中的天数]

　　

　　　　类方法和属性：

date.max     # date对象所能表示的最大日期：9999-12-31
date.min     # date对象所能表示的最小日志：00001-01-01
date.resoluation     # date对象表示的日期的最小单位：天
date.today()     # 返回一个表示当前本地日期的date对象
date.fromtimestamp(timestamp)     # 根据跟定的时间戳，返回一个date对象

　　

　　　　对象方法和属性：

d.year     # 年
d.month     # 月
d.day     # 日
d.replace(year[, month[, day]])     # 生成并返回一个新的日期对象，原日期对象不变
d.timetuple()     # 返回日期对应的time.struct_time对象
d.toordinal()     # 返回日期是是自 0001-01-01 开始的第多少天
d.weekday()     # 返回日期是星期几，[0, 6]，0表示星期一
d.isoweekday()     # 返回日期是星期几，[1, 7], 1表示星期一
d.isocalendar()     # 返回一个元组，格式为：(year, weekday, isoweekday)
d.isoformat()     # 返回‘YYYY-MM-DD’格式的日期字符串
d.strftime(format)     # 返回指定格式的日期字符串，与time模块的strftime(format, struct_time)功能相同

　　

　　　　类方法和属性示例：

import time
import datetime
from datetime import date
 

print(date.max)
# 9999-12-31
 
print(datetime.date(9999, 12, 31))
# 9999-12-31

print(date.min)
# 0001-01-01

print(datetime.date(1, 1, 1))
# 0001-01-01

print(date.resolution)
# 1 day, 0:00:00
 
print(datetime.timedelta(1))
# 1 day, 0:00:00
 
print(date.today())
# 2018-10-11

print(datetime.date(2018, 2, 4))
# 2018-02-04

print(date.fromtimestamp(time.time()))
# 2018-10-11
 
print(datetime.date(2018, 2, 4))
# 2018-02-04

　　　　对象方法和属性示例：

import datetime
from datetime import date


d = date.today()

print(d.year)
# 2018

print(d.month)
# 10

print(d.day)
# 11

print(d.replace(2016))
# 2016-10-11

print(datetime.date(2016, 2, 4))
# datetime.date(2016, 2, 4)

print(d.replace(2016, 3))
# d.replace(2016, 3)

print(d.replace(2016, 3, 2))
# 2016-03-02

print(datetime.date(2016, 3, 2))
# 2016-03-02

print(d.timetuple())
# time.struct_time(tm_year=2018, tm_mon=10, tm_mday=11, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=284, tm_isdst=-1) 

print(d.toordinal())
# 736978

print(d.weekday())
# 3

print(d.isoweekday())
# 4

print(d.isocalendar())
# (2018, 41, 4)

print(d.isoformat())
# 2018-10-11

print(d.ctime())
# Thu Oct 11 00:00:00 2018

print(d.strftime('%Y/%m/%d'))
# 2018/10/11

　　（4）datetime.time类

　　　　time类的定义：

class datetime.time(hour, [minute[, second, [microsecond[, tzinfo]]]])

# hour为必须参数，其他为可选参数。各参数的取值范围为：：

hour     # [0, 23]
minute     # [0, 59]
second     # [0, 59]
microsecond     # [0, 1000000]
tzinfo     # tzinfo的子类对象，如timezone类的实例

　　

　　　　类方法和属性：

time.max     # time类所能表示的最大时间：time(23, 59, 59, 999999)
time.min     # time类所能表示的最小时间：time(0, 0, 0, 0)
time.resolution     # 时间的最小单位，即两个不同时间的最小差值：1微秒

　　

　　　　对象方法和属性：

t.hour     # 时
t.minute     # 分
t.second     # 秒
t.microsecond     # 微秒
t.tzinfo     # 返回传递给time构造方法的tzinfo对象，如果该参数未给出，则返回None
t.replace(hour[, minute[, second[, microsecond[, tzinfo]]]])     # 生成并返回一个新的时间对象，原时间对象不变
t.isoformat()     # 返回一个‘HH:MM:SS.%f’格式的时间字符串
t.strftime()     # 返回指定格式的时间字符串，与time模块的strftime(format, struct_time)功能相同

　　

　　　　类方法和属性示例：

import datetime
from datetime import time


print(time.max)
# 23:59:59.999999

print(datetime.time(23, 59, 59, 999999))
# 23:59:59.999999

print(time.min)
# 00:00:00

print(datetime.time(0, 0))
# 00:00:00

print(time.resolution)
# 0:00:00.000001

print(datetime.timedelta(0, 0, 1))
# 0:00:00.000001

　　

　　　　对象方法和属性示例：

import datetime
from datetime import time

t = time(20, 5, 40, 8888)
print(t.hour)
# 20

print(t.minute)
# 5

print(t.second)
# 40

print(t.microsecond)
# 8888

print(t.tzinfo)
# None

print(t.replace(21))
# 21:05:40.008888

print(datetime.time(21, 5, 40, 8888))
# 21:05:40.008888

print(t.isoformat())
# 21:05:40.008888

print(t.strftime('%H%M%S'))
# 200540

print(t.strftime('%H%M%S.%f'))
# 200540.008888

　　

　　（5）datetime.datetime类

　　　　datetime类的定义：

class datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None)

# year, month 和 day是必须要传递的参数， tzinfo可以是None或tzinfo子类的实例。

# 各参数的取值范围为：
year     # [MINYEAR, MAXYEAR]
month     # [1, 12]
day     # [1, 指定年份的月份中的天数]
hour     # [0, 23]
minute     # [0, 59]
second     # [0, 59]
microsecond     # [0, 1000000]
tzinfo     # tzinfo的子类对象，如timezone类的实例

# 如果一个参数超出了这些范围，会引起ValueError异常。

　　

　　　　类方法和属性：

datetime.today()     # 返回一个表示当前本期日期时间的datetime对象
datetime.now([tz])    # 返回指定时区日期时间的datetime对象，如果不指定tz参数则结果同上
datetime.utcnow()     # 返回当前utc日期时间的datetime对象
datetime.fromtimestamp(timestamp[, tz])     # 根据指定的时间戳创建一个datetime对象
datetime.utcfromtimestamp(timestamp)     # 根据指定的时间戳创建一个datetime对象
datetime.combine(date, time)     # 把指定的date和time对象整合成一个datetime对象
datetime.strptime(date_str, format)     # 将时间字符串转换为datetime对象

　　

　　　　对象方法和属性：

dt.year, dt.month, dt.day     # 年、月、日
dt.hour, dt.minute, dt.second     # 时、分、秒
dt.microsecond, dt.tzinfo     # 微秒、时区信息
dt.date()     # 获取datetime对象对应的date对象
dt.time()     # 获取datetime对象对应的time对象， tzinfo 为None
dt.timetz()     # 获取datetime对象对应的time对象，tzinfo与datetime对象的tzinfo相同
dt.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]])     # 生成并返回一个新的datetime对象，如果所有参数都没有指定，则返回一个与原datetime对象相同的对象
dt.timetuple()     # 返回datetime对象对应的tuple（不包括tzinfo）
dt.utctimetuple()     # 返回datetime对象对应的utc时间的tuple（不包括tzinfo）
dt.toordinal()     # 同date对象
dt.weekday()     # 同date对象
dt.isocalendar()     # 同date独享
dt.isoformat([sep])     # 返回一个‘%Y-%m-%d
dt.ctime()     # 等价于time模块的time.ctime(time.mktime(d.timetuple()))
dt.strftime(format)     # 返回指定格式的时间字符串

　　

　　　　类方法和属性示例：

import time as timer
from datetime import date, time
from datetime import datetime, timezone

t = time(20, 5, 40, 8888)

print(datetime.today())
# 2018-10-11 13:57:05.710107

print(datetime.now())
# 2018-10-11 13:57:05.710107

print(datetime.now(timezone.utc))
# 2018-10-11 05:57:05.710107+00:00

print(datetime.utcnow())
# 2018-10-11 05:57:05.713098

print(datetime.fromtimestamp(timer.time()))
# 2018-10-11 13:57:05.713099

print(datetime.utcfromtimestamp(timer.time()))
# 2018-10-11 13:57:05.713099

print(datetime.combine(date(2018, 2, 4), t))
# 2018-02-04 20:05:40.008888

print(datetime.strptime('2018/02/04 20:49', '%Y/%m/%d %H:%M'))
# 2018-02-04 20:49:00

　　

　　　　对象方法和属性示例：

from datetime import datetime


dt = datetime.now()

print(dt)
# 2018-10-11 13:59:47.210431

print(dt.year)
# 2018

print(dt.month)
# 10

print(dt.day)
# 11

print(dt.hour)
# 13

print(dt.minute)
# 59

print(dt.second)
# 47

print(dt.microsecond)
# 210431

print(dt.tzinfo)
# None

print(dt.timestamp())
# 1539237587.210431

print(dt.date())
# 2018-10-11


print(dt.time())
# 14:01:20.800273

print(dt.timetz())
# 14:01:20.800273

print(dt.replace())
# 2018-10-11 14:01:20.800273

print(dt.replace(2016))
# 2016-10-11 14:01:20.800273

print(dt.timetuple())
# time.struct_time(tm_year=2018, tm_mon=10, tm_mday=11, tm_hour=14, tm_min=1, tm_sec=20, tm_wday=3, tm_yday=284, tm_isdst=-1)

print(dt.utctimetuple())
# time.struct_time(tm_year=2018, tm_mon=10, tm_mday=11, tm_hour=14, tm_min=1, tm_sec=20, tm_wday=3, tm_yday=284, tm_isdst=0)

print(dt.toordinal())
# 736978

print(dt.weekday())
# 3 

print(dt.isocalendar())
# (2018, 41, 4)

print(dt.isoformat())
# (2018, 41, 4)

print(dt.isoformat(sep='/'))
# 2018-10-11/14:01:20.800273

print(dt.isoformat(sep=' '))
# 2018-10-11 14:01:20.800273

print(dt.ctime())
# Thu Oct 11 14:01:20 2018

print(dt.strftime('%Y%m%d %H:%M:%S.%f'))
# 20181011 14:01:20.800273

　

　　（6）使用datetime.datetime类对时间戳与时间字符串进行转换

　　（7）datetime.timedelta类

 　　　　 timedelta对象表示连个不同时间之间的差值。如果使用time模块对时间进行算术运行，只能将字符串格式的时间 和 struct_time格式的时间对象 先转换为时间戳格式，然后对该时间戳加上或减去n秒，最后再转换回struct_time格式或字符串格式，这显然很不方便。而datetime模块提供的timedelta类可以让我们很方面的对datetime.date, datetime.time和datetime.datetime对象做算术运算，且两个时间之间的差值单位也更加容易控制。这个差值的单位可以是：天、秒、微秒、毫秒、分钟、小时、周。

 

　　　　datetime.timedelta类的定义：

　　　　 　　class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, hours=0, weeks=0) 

　　　　　　所有参数都是默认参数，因此都是可选参数。参数的值可以是整数或浮点数，也可以是正数或负数。内部值存储days、seconds 和 microseconds，其他所有参数都将被转换成这3个单位：

　　　　　　　　1毫秒转换为1000微秒
　　　　　　　　1分钟转换为60秒
　　　　　　　　1小时转换为3600秒
　　　　　　　　1周转换为7天

　　　　　　然后对这3个值进行标准化，使得它们的表示是唯一的：

　　　　　　　　microseconds : [0, 999999]
　　　　　　　　seconds : [0, 86399]
　　　　　　　　days : [-999999999, 999999999]

　　　　

　　　　类属性：

timedelta.min     # timedelta(-999999999)
timedelta.max     # timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)
timedelta.resolution     # timedelta(microseconds=1)

　　　　实例方法和属性：

td.days     # 天 [-999999999, 999999999]
td.seconds     # 秒 [0, 86399]
td.microseconds     # 微秒 [0, 999999]
td.total_seconds()     # 时间差中包含的总秒数，等价于: td / timedelta(seconds=1)

 　　　　补充：

datetime.datetime.now()     # 返回当前本地时间（datetime.datetime对象实例）
datetime.datetime.fromtimestamp(timestamp)     # 返回指定时间戳对应的时间（datetime.datetime对象实例）
datetime.timedelta()     # 返回一个时间间隔对象，可以直接与datetime.datetime对象做加减操作

　　　　示例：

import datetime


datetime.timedelta(365).total_seconds()  # 一年包含的总秒数
dt = datetime.datetime.now()

print(dt + datetime.timedelta(3))  # 3天后
# 2018-10-14 14:12:11.528408

print(dt + datetime.timedelta(-3)) # 3天前
# 2018-10-08 14:12:11.528408

print(dt + datetime.timedelta(hours=3))  # 3小时后
# 2018-10-11 17:12:11.528408

print(dt + datetime.timedelta(hours=-3))  # 3小时前
# 2018-10-11 11:12:11.528408

print(dt + datetime.timedelta(hours=3, seconds=30))  # 3小时30秒后
# 2018-10-11 17:12:41.528408

三、时间格式码：

　　time模块的struct_time以及datetime模块的datetime、date、time类都提供了strftime()方法，该方法可 以输出一个指定格式的时间字符串。

　　具体格式由一系列的格式码（格式字符）组成，Python最终调用的是各个平台C库的strftme()函数，因此各平台对全套格式码的支持会有所不同，具体情况需要参考该平台上的strftime(3)文档。

　　下面列出了C标准（1989版）要求的所有格式码，它们在所有标准C实现的平台上都可以工作：