5.Python3标准库-日期和时间

'''
不同于int，str，float，Python没有包含对应日期和时间的原生类型，不过提供了3个相应的模块，可以采用多种表示来管理日期和时间值

time模块由底层C库提供与时间相关的函数。它包含一些函数，可以用于获取时钟时间和处理器运行时间，还提供了基本的解析和字符串格式化工具

datetime模块为日期、时间以及日期时间值提供了一个更高层接口。datetime中的类支持算术、比较和时区配置

calendar模块可以创建周、月、年的格式化表示。它还可以用来计算重复事件，给定日期的话是星期几，以及其他基于日历的值
'''

　　

（一）time：时钟时间

'''
time模块允许访问多种类型的时钟，分别用于不同的用途。
标准系统调用(如time())会报告系统"墙上时钟"时间。monotonic()时钟可以用于测量一个长时间运行的进程的耗用时间，因为即使系统时间有改变，也能保证这个时间不会逆转。
以及其他的功能我们慢慢介绍
'''

　　

1.比较时钟

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.墙上时钟时间

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.单调时钟

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.处理器时钟时间

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.性能计数器

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.时间组成

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.处理时区

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.解析和格式化时间

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：日期和时间值管理

'''
datetime包含一些函数和类，用于完成日期和时间的解析、格式化和算术运算
'''

　　

1.时间

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.日期

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.日期的运算和比较

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.结合日期和时间

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.格式化和解析

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.时区

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：处理日期

import calendar
'''
calendar模块定义了Calendar类，其中封装了一些值的计算，如给定的一个月或一年中的周日期。
另外，TextCalendar和HTMLCalendar类可以生成经过预格式化的输出
'''

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
'''