5.Python3标准库-日期和时间
1
2
3
4
5
6
7
8
9
|
''' 不同于int,str,float,Python没有包含对应日期和时间的原生类型,不过提供了3个相应的模块,可以采用多种表示来管理日期和时间值 time模块由底层C库提供与时间相关的函数。它包含一些函数,可以用于获取时钟时间和处理器运行时间,还提供了基本的解析和字符串格式化工具 datetime模块为日期、时间以及日期时间值提供了一个更高层接口。datetime中的类支持算术、比较和时区配置 calendar模块可以创建周、月、年的格式化表示。它还可以用来计算重复事件,给定日期的话是星期几,以及其他基于日历的值 ''' |
(一)time:时钟时间
1
2
3
4
5
|
''' time模块允许访问多种类型的时钟,分别用于不同的用途。 标准系统调用(如time())会报告系统"墙上时钟"时间。monotonic()时钟可以用于测量一个长时间运行的进程的耗用时间,因为即使系统时间有改变,也能保证这个时间不会逆转。 以及其他的功能我们慢慢介绍 ''' |
1.比较时钟
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
|
import time import textwrap ''' 时钟的实现细节因平台而异。可以使用get_clock_info()获得当前实现的基本信息,包括时钟的分辨率 ''' available_clocks = [ ( "clock" , time.clock), ( "monotonic" , time.monotonic), ( "perf_counter" , time.perf_counter), ( "process_time" , time.process_time), ( "time" , time.time) ] for clock_name, func in available_clocks: info = time.get_clock_info(clock_name) print (textwrap.dedent(f ''' {clock_name}: adjustable: {info.adjustable} implementation: {info.implementation} monotonic: {info.monotonic} resolution: {info.resolution} current: {func()} ''' )) ''' clock: adjustable: False implementation: QueryPerformanceCounter() monotonic: True resolution: 4.109233282817159e-07 current: 0.239568711 monotonic: adjustable: False implementation: GetTickCount64() monotonic: True resolution: 0.015600099999999999 current: 20896.24 perf_counter: adjustable: False implementation: QueryPerformanceCounter() monotonic: True resolution: 4.109233282817159e-07 current: 0.239739244 process_time: adjustable: False implementation: GetProcessTimes() monotonic: True resolution: 1e-07 current: 0.2808018 time: adjustable: True implementation: GetSystemTimeAsFileTime() monotonic: False resolution: 0.015600099999999999 current: 1552032134.9916494 ''' |
2.墙上时钟时间
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
import time ''' time模块的核心函数之一是time(),它会把从"纪元"开始以来的秒数作为一个浮点值返回 ''' print ( "the time is:" , time.time()) # the time is: 1552033201.089945 ''' 纪元是时间测量的起点,对于Unix平台系统这个起点时间就是1970年1月1日0点0分0秒。 time.time()得到结果就是当前时间相对于起点过了多少秒。这个值是一个浮点数,具体的精度依赖于具体的平台 ''' # 浮点数表示对于存储或比较日期很有用,但是对于生成人类可读的表示就有些差强人意了。要记录或打印时间,ctime()或许是更好的选择。 print ( "the time is:" , time.ctime()) # the time is: Fri Mar 8 17:22:59 2019 later = time.time() + 15 # time.ctime可以接收一个时间戳,不传参数的话,默认是当前的时间戳 print ( "15 secs from now:" , time.ctime(later)) # 15 secs from now: Fri Mar 8 17:23:14 2019 |
3.单调时钟
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
import time ''' 由于time()查看系统时钟,并且用户或系统服务可能改变系统时钟来同步多个计算机上的时钟,所以反复调用time()所产生的的值可能向前或向后。 试图测量持续时间或者使用这些时间来完成计算时,这可能会导致意想不到的行为。为了避免这些情况,可以使用monotonic,它总是返回向前的值。 ''' start = time.monotonic() time.sleep( 0.1 ) end = time.monotonic() print (f "start: {start:>9.2f}" ) # start: 27083.08 print (f "end : {end:>9.2f}" ) # end : 27083.18 print (f "span : {end-start:>9.2f}" ) # span : 0.1 ''' 单调时钟的起始点没有被定义,所以返回值只是在与其他时钟值完成计算时完成计算时有用。 在这个例子中,使用monotonic来测量睡眠持续时间 ''' |
4.处理器时钟时间
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
import time import hashlib ''' time()返回的是一个墙上的时钟时间,而clock()返回处理器时钟时间。 clock()返回的值反映了程序运行时使用的实际时间 ''' # 但是不推荐这个方法为什么呢? ''' DeprecationWarning: time.clock has been deprecated in Python 3.3 and will be removed from Python 3.8: use time.perf_counter or time.process_time instead ''' # 所以这个就跳过了 |
5.性能计数器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
|
import time import hashlib ''' 在测量性能时,高分辨率时钟是必不可少的。 要确定最好的时钟数据源,需要有平台特定的知识,Python通过perf_counter()来提供所需的这些知识 ''' data = open (__file__, "rb" ).read() loop_start = time.perf_counter() for i in range ( 5 ): iter_start = time.perf_counter() h = hashlib.sha1() for i in range ( 100000 ): h.update(data) cksum = h.hexdigest() now = time.perf_counter() # 叠加计算循环时间 loop_elapsed = now - loop_start # 计算每一次的循环时间 iter_elapsed = now - iter_start print (f "{time.time(): .3f} : {iter_elapsed: .3f} : {loop_elapsed: .3f}" ) ''' 1552040433.357 : 0.269 : 0.269 1552040433.632 : 0.275 : 0.543 1552040433.901 : 0.269 : 0.812 1552040434.172 : 0.271 : 1.083 1552040434.495 : 0.323 : 1.407 ''' # 类似于monotonic,perf_counter的纪元未定义,所以返回值只用于比较和计算值,而不作为绝对时间 |
6.时间组成
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
|
import time ''' 有些情况下需要把时间存储为过去了多少秒(秒数),但是另外一些情况下,程序需要访问一个时期的各个字段(例如,年月日)。 time模块定义了struct_time来保存日期和时间值,其中分解了各个组成部分以便于访问。 很多函数都要处理struct_time值而不是浮点值 ''' print (time.gmtime()) # time.struct_time(tm_year=2019, tm_mon=3, tm_mday=8, tm_hour=10, tm_min=27, tm_sec=29, tm_wday=4, tm_yday=67, tm_isdst=0) print (time.localtime()) # time.struct_time(tm_year=2019, tm_mon=3, tm_mday=8, tm_hour=18, tm_min=27, tm_sec=53, tm_wday=4, tm_yday=67, tm_isdst=0) print (time.mktime(time.gmtime())) # 1552012197.0 ''' gmtime函数以UTC格式返回当前时间。localtime会返回应用了当前的时区的系统时间,mktime取一个time_struct实例,返回时间戳 ''' def show_struct(s: time.struct_time): print (f "年:" , s.tm_year) print (f "月:" , s.tm_mon) print (f "日:" , s.tm_mday) print (f "时:" , s.tm_hour) print (f "分:" , s.tm_min) print (f "秒:" , s.tm_sec) print (f "这一周的第几天,从0开始,0是周一:" , s.tm_wday) print (f "这一年的第几天:" , s.tm_yday) print (f "是否时夏令时的旗帜:" , s.tm_isdst) show_struct(time.localtime()) ''' 年: 2019 月: 3 日: 8 时: 18 分: 36 秒: 4 这一周的第几天,从0开始,0是周一: 4 这一年的第几天: 67 是否时夏令时的旗帜: 0 ''' # 此外我再补充一下gmtime和localtime,这个和ctime一样。可以接收一个时间戳,如果不传参,那么默认是当前系统的时间戳 print (time.localtime( 1 )) # time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=8, tm_min=0, tm_sec=1, tm_wday=3, tm_yday=1, tm_isdst=0) ''' 相当于从纪元过了1秒钟 ''' |
7.处理时区
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
import time import os ''' 用于确定当前时间的函数有一个前提,即已经设置了时区,其可以由程序设置,也可以使用系统的默认时区。 修改时区不会改变具体的时间,只会改变时间的方式。 要改变时区,需要设置环境变量tz,然后调用tzset()。设置时区时可以指定很多细节,甚至细致到夏令时的开始和结束时间。 不过通常更容易的做法是使用时区名,由底层库推导出其他信息。 ''' def show_zone_info(): print ( "TZ:" , os.environ.get( "TZ" , "not set" )) print ( "tzname:" , time.tzname) print ( "Zone:" , time.timezone, time.timezone / 3600 ) print ( "DST:" , time.daylight) print ( "Time:" , time.ctime()) print ( "-" * 20 ) print ( "Default" ) show_zone_info() ZONES = [ "GMT" , "Europe/Amsterdam" ] for zone in ZONES: # 这两行代码是为了让我们改变时区的,先设置环境变量TZ,然后调用time.tzset() os.environ[ "TZ" ] = zone time.tzset() # 此方法不适用于Windows print ( "zone:" ) show_zone_info() |
8.解析和格式化时间
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
import time ''' 函数strptime和strftime可以在时间值的struct_time表示和字符串表示之间进行转换。 这两个函数支持大量格式化指令,允许不同方式的输入和输出 ''' # 接收一个字符串格式的日期,和以及格式化的参数,得到struct_time parsed = time.strptime( "2018-5-12 16:14:25" , "%Y-%m-%d %H:%M:%S" ) # %H-%M-%S也可以写成%X print (parsed) # time.struct_time(tm_year=2018, tm_mon=5, tm_mday=12, tm_hour=16, tm_min=14, tm_sec=25, tm_wday=5, tm_yday=132, tm_isdst=-1) # 传入一个格式化的参数,和一个struct_time,得到一个字符串格式的日期 print (time.strftime( "%m-%d-%Y %X" , parsed)) # 05-12-2018 16:14:25 # strptime:将字符串格式的日期转为struct_time # strftime:将struct_time转为字符串格式的日期 |
(二)datetime:日期和时间值管理
1
2
3
|
''' datetime包含一些函数和类,用于完成日期和时间的解析、格式化和算术运算 ''' |
1.时间
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
import datetime ''' 时间值可以用time表示。time实例包含hour,minute,second和microsecond属性,还可以包含时区信息。 ''' t = datetime.time( 1 , 2 , 3 ) print (f "hour: {t.hour}" ) # hour: 1 print (f "minute: {t.minute}" ) # minute: 2 print (f "second: {t.second}" ) # second: 3 print (f "microsecond: {t.microsecond}" ) # microsecond: 0 print (f "tzinfo: {t.tzinfo}" ) # tzinfo: None # time实例只包含时间值,而不包含和时间值关联的日期值 print (f "earliest: {datetime.time.min}" ) # earliest: 00:00:00 print (f "latest: {datetime.time.max}" ) # latest: 23:59:59.999999 print (f "resolution: {datetime.time.resolution}" ) # resolution: 0:00:00.000001 |
2.日期
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
import datetime ''' 日期日历值用date类表示。date实例包含year,month,day等属性。使用date()类方法很容易创建一个表示当前日期的日期实例 ''' today = datetime.datetime.today() print (today) # 2019-03-18 17:07:53.787871 print (f "ctime: {today.ctime()}" ) # ctime: Mon Mar 18 17:07:53 2019 # 得到的是一个时间元组 print (today.timetuple()) # time.struct_time(tm_year=2019, tm_mon=3, tm_mday=18, tm_hour=17, tm_min=7, tm_sec=53, tm_wday=0, tm_yday=77, tm_isdst=-1) print (f "original: {today.toordinal()}" ) # original: 737136 print (f "year: {today.year}" ) # year: 2019 print (f "month: {today.month}" ) # month: 3 print (f "day: {today.day}" ) # day: 18 # 创建指定年月的日期,如果不包含时分秒,那么可以使用date函数。 # 包含时分秒使用datetime函数 print (datetime.date( 2018 , 11 , 12 )) # 2018-11-12 print (datetime.datetime( 2018 , 11 , 12 )) # 2018-11-12 00:00:00 print (datetime.datetime( 2018 , 11 , 12 , 23 , 12 )) # 2018-11-12 23:12:00 # 还可以对date进行替换 d = datetime.date( 2018 , 11 , 15 ) print (d.replace(year = 1999 )) # 1999-11-15 print (d.replace(year = 1999 , month = 5 )) # 1999-05-15 |
3.日期的运算和比较
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
import datetime ''' 先来介绍一下时间间隔,timedelta,顾名思义就是隔了多长时间 可以对两个timedelta进行算术运算,也可以结合datetime和timedelta得到一个新的datetime ''' d = datetime.date( 2018 , 12 , 11 ) delta1 = datetime.timedelta(days = 1 ) print (f "next_day: {d+delta1}" ) # next_day: 2018-12-12 delta2 = datetime.timedelta(weeks = 1 ) print (f "next_week: {d+delta2}" ) # next_week: 2018-12-18 delta3 = datetime.timedelta(days = - 1 ) print (f "last_day: {d+delta3}" ) # last_day: 2018-12-10 ''' timedelta支持的参数如下: days, seconds, microseconds, milliseconds, minutes, hours, weeks ''' # 日期也可以进行比较 d1 = datetime.date( 2018 , 12 , 1 ) d2 = datetime.date( 2018 , 8 , 19 ) print (d1 > d2) # True # 日期也可以进行运算 print (d1 - d2) # 104 days, 0:00:00 print ((d1 - d2).days) # 104 |
4.结合日期和时间
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
|
import datetime ''' 使用datetime类可以存储由日期和时间分量构成的值。 date只是包含年月日 datetime则是年月日时分秒 ''' print (f "Now: {datetime.datetime.now()}" ) # Now: 2019-03-18 17:33:57.287297 print (f "Today: {datetime.datetime.today()}" ) # Today: 2019-03-18 17:33:57.287297 # 由于咱们在东八区,所以差了八个小时 print (f "UTC Now: {datetime.datetime.utcnow()}" ) # UTC Now: 2019-03-18 09:33:57.287297 d = datetime.datetime.now() print (d.month) # 3 print (d.year) # 2019 print (d.day) # 18 print (d.hour) # 17 print (d.minute) # 33 print (d.second) # 57 # 此外还可以通过combine方法创建datetime实例 t = datetime.time( 1 , 2 , 3 ) d = datetime.date( 2011 , 12 , 11 ) print (datetime.datetime.combine(d, t)) # 2011-12-11 01:02:03 # 或者通过时间戳来创建 import time t = time.time() + 1000000 print (datetime.datetime.fromtimestamp(t)) # 2019-03-30 07:23:53.256506 # 当然通过时间戳的话,date也是可以的 print (datetime.date.fromtimestamp(t)) # 2019-03-30 |
5.格式化和解析
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
|
import datetime ''' datetime模块和time模块一样也提供了strptime和strftime函数来对字符串和datetime对象进行解析 ''' now = datetime.datetime.now() print (now) # 2019-03-18 17:44:06.537144 # 可以使用datetime实例对象调用,当然也可以使用datetime.datetime.strftime(now, format)方法 s = now.strftime( "%Y-%m-%d ---- %X" ) print ( type (s)) # <class 'str'> print (s) # 2019-03-18 ---- 17:44:06 # 此外还可以将字符串格式的日期转换成datetime对象 s = "2018-12-11 14:25:25" d = datetime.datetime.strptime(s, "%Y-%m-%d %H:%M:%S" ) print ( type (d)) # <class 'datetime.datetime'> print (d) # 2018-12-11 14:25:25 ''' time.strftime: 传入format和struct_time,得到format格式的字符串 datetime.datetime.strftime:传入datetime对象和format,得到format格式的字符串。此外这个方法也可以使用实例去调用 time.strptime:传入日期格式的字符串和format,得到struct_time datetime.datetime.strptime:传入日期格式的字符串和format,得到datetime对象 ''' |
6.时区
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
import datetime ''' 关于设置时区,不推荐datetime模块。可以使用一个第三方模块叫pytz ''' import pytz # 可以看到全部的时区有591个 print ( len (pytz.all_timezones)) # 591 # 可以看到中国的时区有两个,分别是上海和乌鲁木齐 print (pytz.country_timezones( "cn" )) # ['Asia/Shanghai', 'Asia/Urumqi'] print (datetime.datetime.now()) # 2019-03-18 18:10:45.735613 # 设置时区 tz = pytz.timezone( "Asia/Shanghai" ) print (datetime.datetime.now(tz = tz)) # 2019-03-18 18:10:45.736613+08:00 tz = pytz.timezone( "Asia/Urumqi" ) print (datetime.datetime.now(tz = tz)) # 2019-03-18 16:09:35.343587+06:00 ''' 可以看到我所处的时区时Asia/Shanghai,所以设置不设置是一样的, 然而当我设置为乌鲁木齐的时候,会发现早了两个小时。说明当我们这里十二点的时候,乌鲁木齐那里是十点 ''' |
(三)calendar:处理日期
1
2
3
4
5
|
import calendar ''' calendar模块定义了Calendar类,其中封装了一些值的计算,如给定的一个月或一年中的周日期。 另外,TextCalendar和HTMLCalendar类可以生成经过预格式化的输出 ''' |
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
|
import calendar ''' prmonth方法是一个简单的函数,可以生成月的格式化文本输出 ''' c = calendar.TextCalendar() c.prmonth( 2017 , 7 ) ''' July 2017 Mo Tu We Th Fr Sa Su 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ''' # 如果想按照美国的方式,将TextCalendar配置为一周从星期日开始的话,怎么做呢? # 只需要加上一个参数即可,当然也可以指定其它,比如星期五,星期六什么的 calendar.TextCalendar(calendar.SUNDAY).prmonth( 2017 , 7 ) ''' July 2017 Su Mo Tu We Th Fr Sa 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ''' # 此外还有更简单的方法,直接调用模块下的month方法,输入年和月,但需要加上print print (calendar.month( 2017 , 7 )) ''' July 2017 Mo Tu We Th Fr Sa Su 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 ''' |