python时间模块time
时间模块
时间模块主要处理和时间相关的事件，我们可以通过模块获取不同数据类型的时间以便我们需求。
表现时间的三种方式：
在pythn中表现时间的方式主要有三种：时间戳（stamptime）、元祖时间（structtime）、格式化字符串时间，在大多数编程里面也有这些概念。
1、时间戳时间：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。返回的是float类型
2、格式化字符串时间：列如：‘1992-12-1’
3、元祖时间：该元祖共有9个元素(年，月，日，时，分，秒，一年中第几周，一年中第几天等）
时间戳时间
在使用time模块前记得导入模块，下面来看下如何获取时间戳，语法：time.time().
>>> import time
>>> time.time()
1541072964.2124543
注意：time.time()不接受参数，返回是当前时间的时间戳时间，float型。
字符串时间
语法：time.strftime(format,p_tuple=None),该方法接受两个参数，一个是要显示时间的字符串格式，以及元祖时间，该参数为默认参数，不传则获取当前元祖时间来转化成字符串时间，以下是该方法的详细介绍：
def strftime(format, p_tuple=None): # real signature unknown; restored from __doc__
"""
strftime(format[, tuple]) -> string
Convert a time tuple to a string according to a format specification.
See the library reference manual for formatting codes. When the time tuple
is not present, current time as returned by localtime() is used.
Commonly used format codes:
%Y Year with century as a decimal number.
%m Month as a decimal number [01,12].
%d Day of the month as a decimal number [01,31].
%H Hour (24-hour clock) as a decimal number [00,23].
%M Minute as a decimal number [00,59].
%S Second as a decimal number [00,61].
%z Time zone offset from UTC.
%a Locale's abbreviated weekday name.
%A Locale's full weekday name.
%b Locale's abbreviated month name.
%B Locale's full month name.
%c Locale's appropriate date and time representation.
%I Hour (12-hour clock) as a decimal number [01,12].
%p Locale's equivalent of either AM or PM.
Other codes may be available on your platform. See documentation for
the C library strftime function.
"""
return ""
字符串格式中文对照表：
%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 当前时区的名称
%% %号本身
接下来看两个例子：
>>> time.strftime("%Y-%m-%d %X")
'2018-11-01 20:08:46'
>>>time.strftime("%Y-%m-%d %H-%M-%S")
'2017-07-24 13-55-04'
时间元祖
语法1：获取当前时区的时间time.localtime(secends=None),接受一个默认参数（stamptime）时间戳，没传参时默认获取当前的时间戳。
方法介绍：
def localtime(seconds=None): # real signature unknown; restored from __doc__
"""
localtime([seconds]) -> (tm_year,tm_mon,tm_mday,tm_hour,tm_min,
tm_sec,tm_wday,tm_yday,tm_isdst)
Convert seconds since the Epoch to a time tuple expressing local time.
When 'seconds' is not passed in, convert the current time instead.
"""
pass
语法2：获取英国伦敦时间（时间戳是伦敦时间开始time.gmtime(seconds=None)
用法与上面一样。
举例：
>>> time.localtime()
time.struct_time(tm_year=2018, tm_mon=11, tm_mday=1, tm_hour=20, tm_min=18, tm_sec=5, tm_wday=3, tm_yday=305, tm_is
dst=0)
>>> time.gmtime()
time.struct_time(tm_year=2018, tm_mon=11, tm_mday=1, tm_hour=12, tm_min=18, tm_sec=13, tm_wday=3, tm_yday=305, tm_i
sdst=0)
可以看出北京时间比伦敦时间早8小时。
小结：时间戳是计算机能够识别的时间；时间字符串是人能够看懂的时间；元组则是用来操作时间的
几种时间格式之间的转换
1、时间戳<--->元祖时间
时间戳--->元祖时间
语法1：time.localtime(seconds=None),接受时间戳时间参数转化成当地元祖时间。不传参默认获取当前时间戳时间。
#不传参数
>>> time.localtime()
time.struct_time(tm_year=2018, tm_mon=11, tm_mday=1, tm_hour=20, tm_min=24, tm_sec=34, tm_wday=3, tm_yday=305, tm_i
sdst=0)
#自定义传时间戳参数
>>> time.localtime(1231231411)
time.struct_time(tm_year=2009, tm_mon=1, tm_mday=6, tm_hour=16, tm_min=43, tm_sec=31, tm_wday=1, tm_yday=6, tm_isds
t=0)
time.gmtime()用法与time.localtime()用法相同.
元祖时间--->时间戳时间
语法:time.mktime(p_tuple),参数为元祖时间必须传参.
#先获取一个元祖时间
>>> struct_time =time.localtime()
#查看元祖时间
>>> struct_time
time.struct_time(tm_year=2018, tm_mon=11, tm_mday=1, tm_hour=20, tm_min=30, tm_sec=6, tm_wday=3, tm_yday=305, tm_is
dst=0)
#将元祖时间转化成时间戳时间
>>> stamp_time = time.mktime(struct_time)
>>> stamp_time
1541075406.0
2字符串时间<--->元祖时间
2.1字符串--->元祖时间
语法：strptime(string, format) ，接受两个参数，字符串时间以及时间字符串格式
>>> time.strptime('2007-10-10', '%Y-%m-%d')
time.struct_time(tm_year=2007, tm_mon=10, tm_mday=10, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=2, tm_yday=283, tm_isd
st=-1)
2.2、元祖时间--->字符串时间
语法：time.strftime(format,p_tuple)，接受两个参数，字符串时间格式及元祖时间，元祖时间不传默认为当前时间的元祖时间
#只传字符串格式参数
>>> time.strftime('%c')
'Thu Nov 1 20:42:35 2018'
#传入指定的元祖时间
#先获取一个元祖时间
>>> struct_time = time.localtime()
#传入两个参数获取字符串时间
>>> time.strftime('%c',struct_time)
'Thu Nov 1 20:44:23 2018'
总结：
获取时间戳时间方法：
1、time.time()直接获取
2、time.mktime(p_tuple)元祖时间转化时间戳
获取元祖时间方法：
1、time.localtime(seconds=None)、time.gmtime(seconds=None)时间戳转化元祖时间
2、time.strptime(strtime,format)字符串时间转化成元祖时间
获取字符串时间方法：
1、time.strftime(format,p_tuple=None)元祖转化成字符串时间。
小练习题：
要求
输入出生时间和当前时间，计算出过了多长时间。
import time
def livetime(birtime, nowtime):
"""
计算你到现在活了多长时间
:param birtime: 出生时间 字符串时间格式 '%Y-%m-%d %H:%M:%S'
:param nowtime: 现在时间 字符串时间格式 '%Y-%m-%d %H:%M:%S'
:return:返回拼接的字符串 '活了%s年%s月%s天%s时%s分%s秒'
"""
# 1、将出生时间以及现在时间转化成元组时间
bir_struct_time = time.strptime(birtime, '%Y-%m-%d %H:%M:%S')
now_struct_time = time.strptime(nowtime, '%Y-%m-%d %H:%M:%S')
# 2、转化成时间戳时间
bir_stamptime = time.mktime(bir_struct_time)
now_stamptime = time.mktime(now_struct_time)
# 3、计算两者的时间戳差值
live_stamptime = now_stamptime - bir_stamptime
# 4、将差值转化成伦敦元祖时间（伦敦时间1970-1-1 0:0:0）方便计算不会出现借位减的情况
live_struct_time = time.gmtime(live_stamptime)
# 5、返回拼接好的字符串
return '活了%s年%s月%s天%s时%s分%s秒' % (live_struct_time.tm_year - 1970,
live_struct_time.tm_mon - 1,
live_struct_time.tm_mday - 1,
live_struct_time.tm_hour,
live_struct_time.tm_min,
live_struct_time.tm_sec
)
print(livetime('2000-10-10 0:0:0', '2010-10-10 0:0:0'))
