python 时间库 time
在开始之前，首先要说明这几点：
1.在Python中，通常有这几种方式来表示时间：1）时间戳 2）格式化的时间字符串 3）元组（struct_time）共九个元素。由于Python的time模块实现主要调用C库，所以各个平台可能有所不同。
2.UTC（Coordinated Universal Time，世界协调时）亦即格林威治天文时间，世界标准时间。在中国为UTC+8。DST（Daylight Saving Time）即夏令时。
3.时间戳（timestamp）的方式：通常来说，时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。我们运行“type(time.time())”，返回的是float类型。返回时间戳方式的函数主要有time()，clock()等。
4.元组（struct_time）方式：struct_time元组共有9个元素，返回struct_time的函数主要有gmtime()，localtime()，strptime()。下面列出这种方式元组中的几个元素：
| 索引（Index） |
属性（Attribute） |
值(Values) |
| 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（weekday） | 0 - 6（0表示周日） |
| 7 | tm_yday（一年中的第几天） | 1 - 366 |
| 8 | tm_isdst（是否是夏令时） | 默认为-1 |
import time
dir(time)
Out[75]:
['__doc__',
'__name__',
'__package__',
'accept2dyear',
'altzone',
'asctime',
'clock',
'ctime',
'daylight',
'gmtime',
'localtime',
'mktime',
'sleep',
'strftime',
'strptime',
'struct_time',
'time',
'timezone',
'tzname']其中，10个函数，
time 模块类和函数如下：help(time)
Help on built-in module time:
NAME
time - This module provides various functions to manipulate time values.
FILE
(built-in)
DESCRIPTION
There are two standard representations of time. One is the number
of seconds since the Epoch, in UTC (a.k.a. GMT). It may be an integer
or a floating point number (to represent fractions of seconds).
The Epoch is system-defined; on Unix, it is generally January 1st, 1970.
The actual value can be retrieved by calling gmtime(0).
The other representation is a tuple of 9 integers giving local time.
The tuple items are:
year (four digits, e.g. 1998)
month (1-12)
day (1-31)
hours (0-23)
minutes (0-59)
seconds (0-59)
weekday (0-6, Monday is 0)
Julian day (day in the year, 1-366)
DST (Daylight Savings Time) flag (-1, 0 or 1)
If the DST flag is 0, the time is given in the regular time zone;
if it is 1, the time is given in the DST time zone;
if it is -1, mktime() should guess based on the date and time.
Variables:
timezone -- difference in seconds between UTC and local standard time
altzone -- difference in seconds between UTC and local DST time
daylight -- whether local time should reflect DST
tzname -- tuple of (standard time zone name, DST time zone name)
Functions:
time() -- return current time in seconds since the Epoch as a float
clock() -- return CPU time since process start as a float
sleep() -- delay for a number of seconds given as a float
gmtime() -- convert seconds since Epoch to UTC tuple
localtime() -- convert seconds since Epoch to local time tuple
asctime() -- convert time tuple to string
ctime() -- convert time in seconds to string
mktime() -- convert local time tuple to seconds since Epoch
strftime() -- convert time tuple to string according to format specification
strptime() -- parse string to time tuple according to format specification
tzset() -- change the local timezone
CLASSES
__builtin__.object
struct_time
class struct_time(__builtin__.object)
| The time value as returned by gmtime(), localtime(), and strptime(), and
| accepted by asctime(), mktime() and strftime(). May be considered as a
| sequence of 9 integers.
|
| Note that several fields' values are not the same as those defined by
| the C language standard for struct tm. For example, the value of the
| field tm_year is the actual year, not year - 1900. See individual
| fields' descriptions for details.
|
| Methods defined here:
|
| __add__(...)
| x.__add__(y) <==> x+y
|
| __contains__(...)
| x.__contains__(y) <==> y in x
|
| __eq__(...)
| x.__eq__(y) <==> x==y
|
| __ge__(...)
| x.__ge__(y) <==> x>=y
|
| __getitem__(...)
| x.__getitem__(y) <==> x[y]
|
| __getslice__(...)
| x.__getslice__(i, j) <==> x[i:j]
|
| Use of negative indices is not supported.
|
| __gt__(...)
| x.__gt__(y) <==> x>y
|
| __hash__(...)
| x.__hash__() <==> hash(x)
|
| __le__(...)
| x.__le__(y) <==> x<=y
|
| __len__(...)
| x.__len__() <==> len(x)
|
| __lt__(...)
| x.__lt__(y) <==> x x*n
|
| __ne__(...)
| x.__ne__(y) <==> x!=y
|
| __reduce__(...)
|
| __repr__(...)
| x.__repr__() <==> repr(x)
|
| __rmul__(...)
| x.__rmul__(n) <==> n*x
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| tm_hour
| hours, range [0, 23]
|
| tm_isdst
| 1 if summer time is in effect, 0 if not, and -1 if unknown
|
| tm_mday
| day of month, range [1, 31]
|
| tm_min
| minutes, range [0, 59]
|
| tm_mon
| month of year, range [1, 12]
|
| tm_sec
| seconds, range [0, 61])
|
| tm_wday
| day of week, range [0, 6], Monday is 0
|
| tm_yday
| day of year, range [1, 366]
|
| tm_year
| year, for example, 1993
|
| ----------------------------------------------------------------------
| Data and other attributes defined here:
|
| __new__ =
| T.__new__(S, ...) -> a new object with type S, a subtype of T
|
| n_fields = 9
|
| n_sequence_fields = 9
|
| n_unnamed_fields = 0
FUNCTIONS
asctime(...)
asctime([tuple]) -> string
Convert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.
When the time tuple is not present, current time as returned by localtime()
is used.
clock(...)
clock() -> floating point number
Return the CPU time or real time since the start of the process or since
the first call to clock(). This has as much precision as the system
records.
ctime(...)
ctime(seconds) -> string
Convert a time in seconds since the Epoch to a string in local time.
This is equivalent to asctime(localtime(seconds)). When the time tuple is
not present, current time as returned by localtime() is used.
gmtime(...)
gmtime([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 UTC (a.k.a.
GMT). When 'seconds' is not passed in, convert the current time instead.
localtime(...)
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.
mktime(...)
mktime(tuple) -> floating point number
Convert a time tuple in local time to seconds since the Epoch.
sleep(...)
sleep(seconds)
Delay execution for a given number of seconds. The argument may be
a floating point number for subsecond precision.
strftime(...)
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.
strptime(...)
strptime(string, format) -> struct_time
Parse a string to a time tuple according to a format specification.
See the library reference manual for formatting codes (same as strftime()).
time(...)
time() -> floating point number
Return the current time in seconds since the Epoch.
Fractions of a second may be present if the system clock provides them.
DATA
accept2dyear = 1
altzone = -32400
daylight = 0
timezone = -28800
tzname = ('\xd6\xd0\xb9\xfa\xb1\xea\xd7\xbc\xca\xb1\xbc\xe4', '\xd6\xd...
接着介绍time模块中常用的几个函数：
1）time.localtime([secs])：将一个时间戳转换为当前时区的struct_time。secs参数未提供，则以当前时间为准。
import time
time.localtime()
Out[97]: time.struct_time(tm_year=2017, tm_mon=6, tm_mday=6, tm_hour=15, tm_min=55, tm_sec=46, tm_wday=1, tm_yday=157, tm_isdst=0)
time.time()
Out[98]: 1496735773.247
time.localtime(1496735773.247)
Out[99]: time.struct_time(tm_year=2017, tm_mon=6, tm_mday=6, tm_hour=15, tm_min=56, tm_sec=13, tm_wday=1, tm_yday=157, tm_isdst=0)
2）time.gmtime([secs])：和localtime()方法类似，gmtime()方法是将一个时间戳转换为UTC时区（0时区）的struct_time。
time.gmtime()
Out[100]: time.struct_time(tm_year=2017, tm_mon=6, tm_mday=6, tm_hour=7, tm_min=57, tm_sec=52, tm_wday=1, tm_yday=157, tm_isdst=0)
time.time()
Out[101]: 1496735924.162
time.localtime()
Out[104]: time.struct_time(tm_year=2017, tm_mon=6, tm_mday=6, tm_hour=16, tm_min=0, tm_sec=4, tm_wday=1, tm_yday=157, tm_isdst=0)
time.mktime(time.localtime())
Out[105]: 1496736016.0
5）time.sleep(secs)：线程推迟指定的时间运行。单位为秒。
time.sleep(50)
6）time.clock()：这个需要注意，在不同的系统上含义不同。在UNIX系统上，它返回的是“进程时间”，它是用秒表示的浮点数（时间戳）。而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时间。（实际上是以WIN32上QueryPerformanceCounter()为基础，它比毫秒表示更为精确）
import time
if __name__ == '__main__':
time.sleep(1)
print "clock1:%s" %time.clock()
time.sleep(5)
print "clock2:%s" %time.clock()
time.sleep(1)
print "clock3:%s" %time.clock()
clock1:1.99570125949e-06
clock2:5.00076321318
clock3:6.00228393754其中第一个clock()输出的是程序运行时间
第二、三个clock()输出的都是与第一个clock的时间间隔
time.asctime()
Out[111]: 'Tue Jun 06 16:12:51 2017'8）time.ctime([secs])：把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果参数未给或者为None的时候，将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。
if __name__ == '__main__':
a = time.ctime()
print "a = ",a
b = time.time()
print "b = ",b
c = time.ctime(b)
print "c = ",c
d = time.ctime(1496735990)
print "d = ",d
a = Tue Jun 06 16:17:24 2017
b = 1496737044.71
c = Tue Jun 06 16:17:24 2017
d = Tue Jun 06 15:59:50 2017
9）time.strftime(format[, t])：把一个代表时间的元组或者struct_time（如由time.localtime()和time.gmtime()返回）转化为格式化的时间字符串。如果t未指定，将传入time.localtime()。如果元组中任何一个元素越界，ValueError的错误将会被抛出。
| 格式 |
含义 |
备注 |
| %a | 本地（locale）简化星期名称 | |
| %A | 本地完整星期名称 | |
| %b | 本地简化月份名称 | |
| %B | 本地完整月份名称 | |
| %c | 本地相应的日期和时间表示 | |
| %d | 一个月中的第几天（01 - 31） | |
| %H | 一天中的第几个小时（24小时制，00 - 23） | |
| %I | 第几个小时（12小时制，01 - 12） | |
| %j | 一年中的第几天（001 - 366） | |
| %m | 月份（01 - 12） | |
| %M | 分钟数（00 - 59） | |
| %p | 本地am或者pm的相应符 | 一 |
| %S | 秒（01 - 61） | 二 |
| %U | 一年中的星期数。（00 - 53星期天是一个星期的开始。）第一个星期天之前的所有天数都放在第0周。 | 三 |
| %w | 一个星期中的第几天（0 - 6，0是星期天） | 三 |
| %W | 和%U基本相同，不同的是%W以星期一为一个星期的开始。 | |
| %x | 本地相应日期 | |
| %X | 本地相应时间 | |
| %y | 去掉世纪的年份（00 - 99） | |
| %Y | 完整的年份 | |
| %Z | 时区的名字（如果不存在为空字符） | |
| %% | ‘%'字符 | |
备注：
“%p”只有与“%I”配合使用才有效果。
文档中强调确实是0 - 61，而不是59，闰年秒占两秒（汗一个）。
当使用strptime()函数时，只有当在这年中的周数和天数被确定的时候%U和%W才会被计算。
举个例子：
a = time.localtime()
a
Out[114]: time.struct_time(tm_year=2017, tm_mon=6, tm_mday=6, tm_hour=16, tm_min=36, tm_sec=43, tm_wday=1, tm_yday=157, tm_isdst=0)
b = time.strftime("%Y-%m-%d %X",a)
b
Out[116]: '2017-06-06 16:36:43'
c = time.strptime(b,'%Y-%m-%d %X')
c
Out[118]: time.struct_time(tm_year=2017, tm_mon=6, tm_mday=6, tm_hour=16, tm_min=36, tm_sec=43, tm_wday=1, tm_yday=157, tm_isdst=-1)
a = time.localtime()
a
Out[114]: time.struct_time(tm_year=2017, tm_mon=6, tm_mday=6, tm_hour=16, tm_min=36, tm_sec=43, tm_wday=1, tm_yday=157, tm_isdst=0)
b = time.strftime("%Y-%m-%d %X",a)
b
Out[116]: '2017-06-06 16:36:43'
c = time.strptime(b,'%Y-%m-%d %X')
c
Out[118]: time.struct_time(tm_year=2017, tm_mon=6, tm_mday=6, tm_hour=16, tm_min=36, tm_sec=43, tm_wday=1, tm_yday=157, tm_isdst=-1)在这个函数中，format默认为："%a %b %d %H:%M:%S %Y"。
最后，我们来对time模块进行一个总结。根据之前描述，在Python中共有三种表达方式：1）timestamp 2）tuple或者struct_time 3）格式化字符串。
它们之间的转化如图所示：
实例：
import datetime
import time
a = time.localtime()
b = time.strftime("%Y-%m-%d %X",a)
c = datetime.datetime.strptime(date, '%Y-%m-%d %H:%M:%S')
b
Out[92]: '2017-06-06 15:26:30'
c
Out[94]: datetime.datetime(2017, 6, 6, 15, 23, 15)