python工具模块介绍-time 时间访问和转换

Posted pythontesting

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了python工具模块介绍-time 时间访问和转换相关的知识,希望对你有一定的参考价值。

快速入门

In [1]: import time

# 获取当前时间
In [25]: time.strftime("%Y-%m-%d_%H-%M-%S", time.localtime()) 
Out[25]: \'2018-06-17_20-05-36\'
# 停顿0.5秒
In [26]: time.sleep(0.5)

简介

功能:时间访问和转换。

相关模块:

datetime 标准模块。
calendar 标准模块。

下面介绍一些术语和约定:

epoch是时间开始点。对于Unix ,时代是1970年1月1日0点。通过time.gmtime(0)可以查看时间的起点:

In [1]: import time

In [2]: time.gmtime(0)
Out[2]: time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)

In [3]:  time.gmtime(time.time() + 786041553) # 32位会报错
Out[3]: time.struct_time(tm_year=2043, tm_mon=5, tm_mday=8, tm_hour=6, tm_min=26, tm_sec=50, tm_wday=4, tm_yday=128, tm_isdst=0)

对于32位的linux系统,时间只能处理到2038年。现在新发布的主流已经全部是64位版本。

UTC是协调世界时(前身为格林威治标准时间或GMT)。

DST为夏令时,通常是根据当地法律在一年内的部分时间进行一小时的调整。 C库包含有当地规则的表。

实时函数的精度可能比建议的要低。例如在大多数Unix系统中,时钟“滴答”只有50或100次每秒。

不过time()和sleep()比Unix的更好:时间为浮点数,time()的返回确保最精确(尽量使用Unix的函数gettimeofday()) ,sleep()接受的时间为非零分数(尽量用select()实现) 。

gmtime(), localtime()和strptime()的返回是包含9个整数的序列,可以作为asctime(), mktime() and strftime()的输入,每个域都有自己的属性,实际上是一个结构体struct_time,参见上面的例子。

时间转换:gmtime()把浮点时间转为UTC的struct_time,反之calendar.timegm();localtime()把浮点时间转为local的struct_time,反之mktime()。实际上calendar.timegm()和mktime()是等效的,不过前者返回整数,后者返回浮点数。

时间生成与转换

生成epoch的浮点数,注意不同的系统精度不同,linux一般是小数点后面7为,windows一般是小数点后3位。Time函数是没有参数的。可以直接对返回的浮点数进行计算。
gmtime([secs])把浮点时间转为UTC的struct_time,如果无输入参数为空会调用time()读取当前时间。
gmtime显示的是世界协调时间, localtime([secs])可以显示本地时间。
注意夏时制要设置dst。asctime([t])显示时间为可读性好的格式,它把gmtime(), localtime()和strptime()的返回的struct_time类型转换为可读性较好的格式。如果输入参数为空则调用localtime()的返回结果。它和c函数不同的地方是末尾不会添加换行。asctime不会使用Locale信息。

ctime([secs])在asctime上更进一步,转换浮点数为可读性较好的格式,相当于asctime(localtime(secs)), 这个功能很常用。ctime不会使用Locale信息。

In [1]: import time

In [2]: time.gmtime(0)
Out[2]: time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)

In [3]:  time.gmtime(time.time() + 786041553)
Out[3]: time.struct_time(tm_year=2043, tm_mon=5, tm_mday=8, tm_hour=6, tm_min=26, tm_sec=50, tm_wday=4, tm_yday=128, tm_isdst=0)

In [4]: time.time()
Out[4]: 1528637996.277831

In [5]: time.gmtime()
Out[5]: time.struct_time(tm_year=2018, tm_mon=6, tm_mday=10, tm_hour=13, tm_min=42, tm_sec=47, tm_wday=6, tm_yday=161, tm_isdst=0)

In [6]: time.localtime()
Out[6]: time.struct_time(tm_year=2018, tm_mon=6, tm_mday=10, tm_hour=21, tm_min=43, tm_sec=54, tm_wday=6, tm_yday=161, tm_isdst=0)

In [7]: time.asctime()
Out[7]: \'Sun Jun 10 22:10:14 2018\'

In [8]: time.ctime()
Out[8]: \'Sun Jun 10 22:12:25 2018\'

Sleep

sleep(secs)暂停执行指定秒数。参数可以是整数或浮点数。实际的中止时间可能小于请求时间,因为例行的信号捕捉可能终止sleep。此外中止时间可能长于请求时间,因为因为系统调度也是需要时间的。

In [36]: time.sleep(3)

处理器时间

clock()在Unix上,返回当前的处理器时间,为以秒表示的浮点数。精度决于同名的C函数,通常用于基准Python或定时的算法。我们书写一个不耗cpu和耗cpu的脚本对比:

import time

template = \' - :0.2f - :0.2f\'

print(template.format(
    time.ctime(), time.time(), time.clock())
)

for i in range(3, 0, -1):
    print(\'Sleeping\', i)
    time.sleep(i)
    print(template.format(
        time.ctime(), time.time(), time.clock())
    )

执行结果:

$ python3 time_clock_sleep.py 
Mon Jun 18 01:27:52 2018 - 1529256472.83 - 0.05
Sleeping 3
Mon Jun 18 01:27:55 2018 - 1529256475.83 - 0.05
Sleeping 2
Mon Jun 18 01:27:57 2018 - 1529256477.83 - 0.05
Sleeping 1
Mon Jun 18 01:27:58 2018 - 1529256478.83 - 0.05

import hashlib
import time

# Data to use to calculate md5 checksums
data = open(__file__, \'rb\').read()

for i in range(5):
    h = hashlib.sha1()
    print(time.ctime(), \': :0.3f :0.3f\'.format(
        time.time(), time.clock()))
    for i in range(300000):
        h.update(data)
    cksum = h.digest()

执行结果:

$ python3 time_clock.py 
Mon Jun 18 01:31:35 2018 : 1529256695.695 0.048
Mon Jun 18 01:31:36 2018 : 1529256696.166 0.519
Mon Jun 18 01:31:36 2018 : 1529256696.635 0.987
Mon Jun 18 01:31:37 2018 : 1529256697.110 1.461
Mon Jun 18 01:31:37 2018 : 1529256697.587 1.936

struct_time类

struct_time是的命名元组,结构如下:

| 索引(Index) | 属性(Attribute) | 值(Values) |
| 0 | tm_year(年 | 比如2013 |
| 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 timedef show_struct(s):
    print \'  tm_year :\', s.tm_year    print \'  tm_mon  :\', s.tm_mon    print \'  tm_mday :\', s.tm_mday    print \'  tm_hour :\', s.tm_hour    print \'  tm_min  :\', s.tm_min    print \'  tm_sec  :\', s.tm_sec    print \'  tm_wday :\', s.tm_wday    print \'  tm_yday :\', s.tm_yday    print \'  tm_isdst:\', s.tm_isdstprint \'gmtime:\'show_struct(time.gmtime())print \'\\nlocaltime:\'show_struct(time.localtime())print \'\\nmktime:\', time.mktime(time.localtime())

执行结果:

$ python3 time_struct.py 
gmtime:
  tm_year : 2018
  tm_mon  : 6
  tm_mday : 17
  tm_hour : 17
  tm_min  : 32
  tm_sec  : 54
  tm_wday : 6
  tm_yday : 168
  tm_isdst: 0

localtime:
  tm_year : 2018
  tm_mon  : 6
  tm_mday : 18
  tm_hour : 1
  tm_min  : 32
  tm_sec  : 54
  tm_wday : 0
  tm_yday : 169
  tm_isdst: 0

mktime: 1529256774.0

参考资料

参考资料

时区

重置库函数的时间转换规则。实际上是修改环境变量TZ,python 2.3以后类linux支持该功能,这个功能相对不是那么常用。TZ环境变量的格式如下:

std offset [dst [offset [,start[/time], end[/time]]]]

STD和DST为时区缩写。hh[:mm[:ss]],表示加上这个时间可以得到UTC时间。偏移量的形式为: HH [ : MM [ : SS] ],夏时制增加1小时。

starttime, endtime表示使用夏时制的区间。time和偏移类似,默认时间是02:00:00。比如:

In [1]: import os

In [2]: import time

In [3]: os.environ[\'TZ\'] = \'EST+05EDT,M4.1.0,M10.5.0\'

In [4]: time.tzset()

In [5]: time.strftime(\'%X %x %Z\')
Out[5]: \'13:38:26 06/17/18 EDT\'

In [6]: os.environ[\'TZ\'] = \'AEST-10AEDT-11,M10.5.0,M3.5.0\'

In [7]: time.tzset()

In [8]: time.strftime(\'%X %x %Z\')
Out[8]: \'03:38:46 06/18/18 AEST\'

在许多Unix系统(包括* BSD,Linux和Solaris,和Darwin),使用系统时区数据库更方便。

In [9]: os.environ[\'TZ\'] = \'US/Eastern\'

In [10]:  time.tzset()

In [11]: time.tzname
Out[11]: (\'EST\', \'EDT\')

In [12]:  os.environ[\'TZ\'] = \'Egypt\'

In [13]:  time.tzset()

In [14]: (\'EET\', \'EEST\')
Out[14]: (\'EET\', \'EEST\')

另一实例:

import time
import os
def show_zone_info():
    print \'  TZ    :\', os.environ.get(\'TZ\', \'(not set)\')
    print \'  tzname:\', time.tzname    print \'  Zone  : %d (%d)\' % (time.timezone,
                                 (time.timezone / 3600))
    print \'  DST   :\', time.daylight    print \'  Time  :\', time.ctime()
    printprint \'Default :\'show_zone_info()ZONES = [ \'GMT\',
          \'Europe/Amsterdam\',
          ]for zone in ZONES:
    os.environ[\'TZ\'] = zone
    time.tzset()
    print zone, \':\'
    show_zone_info()

执行结果:

$ python3 time_timezone.py 
Default :
  TZ    : (not set)
  tzname: (\'CST\', \'CST\')
  Zone  : -28800 (-8.0)
  DST   : 0
  Time  : Mon Jun 18 01:40:39 2018

GMT :
  TZ    : GMT
  tzname: (\'GMT\', \'GMT\')
  Zone  : 0 (0.0)
  DST   : 0
  Time  : Sun Jun 17 17:40:39 2018

Europe/Amsterdam :
  TZ    : Europe/Amsterdam
  tzname: (\'CET\', \'CEST\')
  Zone  : -3600 (-1.0)
  DST   : 1
  Time  : Sun Jun 17 19:40:39 2018

格式化

time.strftime(format[, t]):把一个代表时间的元组或者struct_tim转为格式化的时间字符串。如果t未指定,将调用time.localtime()的返回作为输入。如果输入中任何一个元素越界将报ValueError异常。格式化参数如下:

格式 含义 备注
%a 本地简化星期名
%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基本相同,以星期一为星期的开始。
%x 本地相应日期表示
%X 本地相应时间表示
%y 去掉世纪的年份(00 - 99)
%Y 完整的年份
%Z 时区的名字(如果不存在为空字符)
%% \'%’字符

备注:

  • “%p”只有与“%I”配合使用才有效果。

  • 秒是0 - 61,而不是59,以处理闰秒和双闰秒。

  • 当使用strptime()函数时,只有当在这年中的周数和天数被确定的时候%U和%W才会被计算。

比如:

In [15]: time.strftime("%a, %d %b %Y %H:%M:%S +0000", time.gmtime())
Out[15]: \'Sun, 17 Jun 2018 17:44:12 +0000\'

下面方式在给文件名等添加时间戳比较有用:

In [17]: time.strftime("%Y-%m-%d_%H:%M:%S", time.gmtime())
Out[17]: \'2018-06-17_17:46:18\'

显示格式可能因系统而又不同的差异。

time.strptime(string[, format]):把一个格式化时间字符串转化为struct_time。实际上它和strftime()是逆操作,参数参见strftime。Format默认为"%a %b %d %H:%M:%S %Y",和ctime的返回格式一致,没有提供的值会采用默认值(1900, 1, 1, 0, 0, 0, 0, 1, -1)。

In [19]: time.strptime("30 Nov 18", "%d %b %y")
    ...: 
Out[19]: time.struct_time(tm_year=2018, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=334, tm_isdst=-1)

其他

altzone属性查看当前夏时制时间的偏移。daylight属性查看是否使用了夏时制。timezone查看当前时区的偏移。Tzname返回本地时区和夏时制对应的时区。

In [3]: time.altzone
Out[3]: -28800
In [4]: time.daylight
Out[4]: 0
In [5]: time.timezone
Out[5]: -28800
In [6]: time.tzname
Out[6]: (\'CST\', \'CST\')

python标准库介绍——12 time 模块详解

==time 模块==


``time`` 模块提供了一些处理日期和一天内时间的函数. 它是建立在 C 运行时库的简单封装. 

给定的日期和时间可以被表示为浮点型(从参考时间, 通常是 1970.1.1 到现在经过的秒数. 
即 Unix 格式), 或者一个表示时间的 struct (类元组). 

=== 获得当前时间===

[Example 1-79 #eg-1-79] 展示了如何使用 ``time`` 模块获取当前时间.

====Example 1-79. 使用 time 模块获取当前时间====[eg-1-79]

```
File: time-example-1.py

import time

now = time.time()

print now, "seconds since", time.gmtime(0)[:6]
print
print "or in other words:"
print "- local time:", time.localtime(now)
print "- utc:", time.gmtime(now)

*B*937758359.77 seconds since (1970, 1, 1, 0, 0, 0)

or in other words:
- local time: (1999, 9, 19, 18, 25, 59, 6, 262, 1)
- utc: (1999, 9, 19, 16, 25, 59, 6, 262, 0)*b*
```

``localtime`` 和 ``gmtime`` 返回的类元组包括年, 月, 日, 时, 分, 秒, 星期, 一年的第几天, 日光标志. 
其中年是一个四位数(在有千年虫问题的平台上另有规定, 但还是四位数), 星期从星期一(数字 0 代表)开始, 
1月1日是一年的第一天. 

=== 将时间值转换为字符串===

你可以使用标准的格式化字符串把时间对象转换为字符串, 不过 ``time`` 模块已经提供了许多标准转换函数, 
如 [Example 1-80 #eg-1-80] 所示. 

====Example 1-80. 使用 time 模块格式化时间输出====[eg-1-80]

```
File: time-example-2.py

import time

now = time.localtime(time.time())

print time.asctime(now)
print time.strftime("%y/%m/%d %H:%M", now)
print time.strftime("%a %b %d", now)
print time.strftime("%c", now)
print time.strftime("%I %p", now)
print time.strftime("%Y-%m-%d %H:%M:%S %Z", now)

# do it by hand...
year, month, day, hour, minute, second, weekday, yearday, daylight = now
print "%04d-%02d-%02d" % (year, month, day)
print "%02d:%02d:%02d" % (hour, minute, second)
print ("MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN")[weekday], yearday

*B*Sun Oct 10 21:39:24 1999
99/10/10 21:39
Sun Oct 10
Sun Oct 10 21:39:24 1999
09 PM
1999-10-10 21:39:24 CEST
1999-10-10
21:39:24
SUN 283*b*
```

===将字符串转换为时间对象===

在一些平台上, ``time`` 模块包含了 ``strptime`` 函数, 它的作用与 ``strftime`` 相反. 
给定一个字符串和模式, 它返回相应的时间对象, 如 [Example 1-81 #eg-1-81] 所示. 

====Example 1-81. 使用 time.strptime 函数解析时间====[eg-1-81]

```
File: time-example-6.py

import time

# make sure we have a strptime function!
# 确认有函数 strptime
try:
    strptime = time.strptime
except AttributeError:
    from strptime import strptime

print strptime("31 Nov 00", "%d %b %y")
print strptime("1 Jan 70 1:30pm", "%d %b %y %I:%M%p")
```

只有在系统的 C 库提供了相应的函数的时候, ``time.strptime`` 函数才可以使用. 
对于没有提供标准实现的平台, [Example 1-82 #eg-1-82] 提供了一个不完全的实现. 

====Example 1-82. strptime 实现====[eg-1-82]

```
File: strptime.py

import re
import string

MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug",
          "Sep", "Oct", "Nov", "Dec"]

SPEC = {
    # map formatting code to a regular expression fragment
    "%a": "(?P<weekday>[a-z]+)",
    "%A": "(?P<weekday>[a-z]+)",
    "%b": "(?P<month>[a-z]+)",
    "%B": "(?P<month>[a-z]+)",
    "%C": "(?P<century>\d\d?)",
    "%d": "(?P<day>\d\d?)",
    "%D": "(?P<month>\d\d?)/(?P<day>\d\d?)/(?P<year>\d\d)",
    "%e": "(?P<day>\d\d?)",
    "%h": "(?P<month>[a-z]+)",
    "%H": "(?P<hour>\d\d?)",
    "%I": "(?P<hour12>\d\d?)",
    "%j": "(?P<yearday>\d\d?\d?)",
    "%m": "(?P<month>\d\d?)",
    "%M": "(?P<minute>\d\d?)",
    "%p": "(?P<ampm12>am|pm)",
    "%R": "(?P<hour>\d\d?):(?P<minute>\d\d?)",
    "%S": "(?P<second>\d\d?)",
    "%T": "(?P<hour>\d\d?):(?P<minute>\d\d?):(?P<second>\d\d?)",
    "%U": "(?P<week>\d\d)",
    "%w": "(?P<weekday>\d)",
    "%W": "(?P<weekday>\d\d)",
    "%y": "(?P<year>\d\d)",
    "%Y": "(?P<year>\d\d\d\d)",
    "%%": "%"
}

class TimeParser:
    def _ _init_ _(self, format):
        # convert strptime format string to regular expression
        format = string.join(re.split("(?:\s|%t|%n)+", format))
        pattern = []
        try:
            for spec in re.findall("%\w|%%|.", format):
                if spec[0] == "%":
                    spec = SPEC[spec]
                pattern.append(spec)
        except KeyError:
            raise ValueError, "unknown specificer: %s" % spec
        self.pattern = re.compile("(?i)" + string.join(pattern, ""))
    def match(self, daytime):
        # match time string
        match = self.pattern.match(daytime)
        if not match:
            raise ValueError, "format mismatch"
        get = match.groupdict().get
        tm = [0] * 9
        # extract date elements
        y = get("year")
        if y:
            y = int(y)
            if y < 68:
                y = 2000 + y
            elif y < 100:
                y = 1900 + y
            tm[0] = y
        m = get("month")
        if m:
            if m in MONTHS:
                m = MONTHS.index(m) + 1
            tm[1] = int(m)
        d = get("day")
        if d: tm[2] = int(d)
        # extract time elements
        h = get("hour")
        if h:
            tm[3] = int(h)
        else:
            h = get("hour12")
            if h:
                h = int(h)
                if string.lower(get("ampm12", "")) == "pm":
                    h = h + 12
                tm[3] = h
        m = get("minute")
        if m: tm[4] = int(m)
        s = get("second")
        if s: tm[5] = int(s)
        # ignore weekday/yearday for now
        return tuple(tm)

def strptime(string, format="%a %b %d %H:%M:%S %Y"):
    return TimeParser(format).match(string)

if _ _name_ _ == "_ _main_ _":
    # try it out
    import time
    print strptime("2000-12-20 01:02:03", "%Y-%m-%d %H:%M:%S")
    print strptime(time.ctime(time.time()))

*B*(2000, 12, 20, 1, 2, 3, 0, 0, 0)
(2000, 11, 15, 12, 30, 45, 0, 0, 0)*b*
```

=== 转换时间值===

将时间元组转换回时间值非常简单, 至少我们谈论的当地时间 (local time) 如此. 
只要把时间元组传递给 ``mktime`` 函数, 如 [Example 1-83 #eg-1-83] 所示. 

====Example 1-83. 使用 time 模块将本地时间元组转换为时间值(整数)====[eg-1-83]

```
File: time-example-3.py

import time

t0 = time.time()
tm = time.localtime(t0)

print tm

print t0
print time.mktime(tm)

*B*(1999, 9, 9, 0, 11, 8, 3, 252, 1)
936828668.16
936828668.0*b*
```

但是, 1.5.2 版本的标准库没有提供能将 UTC 时间
(Universal Time, Coordinated: 特林威治标准时间)转换为时间值的函数 
( Python 和对应底层 C 库都没有提供). [Example 1-84 #eg-1-84] 提供了该函数的一个 
Python 实现, 称为 ``timegm`` . 

====Example 1-84. 将 UTC 时间元组转换为时间值(整数)====[eg-1-84]

```
File: time-example-4.py

import time

def _d(y, m, d, days=(0,31,59,90,120,151,181,212,243,273,304,334,365)):
    # map a date to the number of days from a reference point
    return (((y - 1901)*1461)/4 + days[m-1] + d +
        ((m > 2 and not y % 4 and (y % 100 or not y % 400)) and 1))

def timegm(tm, epoch=_d(1970,1,1)):
    year, month, day, h, m, s = tm[:6]
    assert year >= 1970
    assert 1 <= month <= 12
    return (_d(year, month, day) - epoch)*86400 + h*3600 + m*60 + s

t0 = time.time()
tm = time.gmtime(t0)

print tm

print t0
print timegm(tm)

*B*(1999, 9, 8, 22, 12, 12, 2, 251, 0)
936828732.48
936828732*b*
```

从 1.6 版本开始, ``calendar`` 模块提供了一个类似的函数 ``calendar.timegm`` . 

=== Timing 相关===

``time`` 模块可以计算 Python 程序的执行时间, 如 [Example 1-85 #eg-1-85] 所示. 
你可以测量 "wall time" (real world time), 或是"进程时间" (消耗的 CPU 时间). 

====Example 1-85. 使用 time 模块评价算法====[eg-1-85]

```
File: time-example-5.py

import time

def procedure():
    time.sleep(2.5)

# measure process time
t0 = time.clock()
procedure()
print time.clock() - t0, "seconds process time"

# measure wall time
t0 = time.time()
procedure()
print time.time() - t0, "seconds wall time"

*B*0.0 seconds process time
2.50903499126 seconds wall time*b*
```

并不是所有的系统都能测量真实的进程时间. 一些系统中(包括 Windows ), 
``clock`` 函数通常测量从程序启动到测量时的 wall time. 

进程时间的精度受限制. 在一些系统中, 它超过 30 分钟后进程会被清理.
(原文: On many systems, it wraps around after just over 30 minutes.) 

另参见 ``timing`` 模块( Windows 下的朋友不用忙活了,没有地~), 它可以测量两个事件之间的 wall time. 

  

以上是关于python工具模块介绍-time 时间访问和转换的主要内容,如果未能解决你的问题,请参考以下文章

Python常用模块——time&datetime模块

Python_time模块

Python常用模块之time和datetime

Python time模块时间转换

Python中time模块和datetime模块的常用操作以及几种常用时间格式间的转换

python基础===时间处理模块