time,datetime,calendar模块使用方法详解

Python 有很多种方式处理日期和时间，常见的时间处理的模块是datetime、time、calendar。
能融汇贯通的了解和使用这三个模块，才能轻而易举地用python处理时间。

datetime（日期时间）模块主要是用来表示日期的，就是我们常说的年月日时分秒，
calendar（日历）模块主要是用来表示年月日，是星期几之类的信息.
time（时间）模块主要侧重点在时分秒.

datetime对象就是date对象和time对象的组合。
# 导入datetime模块三个核心的类
from datetime import datetime # class one:datetime 日期时间
from datetime import date # class two:date 日期
from datetime import time # class three:time 时间

-创建
    直接将时间的值逐个以参数的形式来创建
    datetime(year,month,day,hour,minute,second,mircosecond)
    date(year,month,day)
    time(hour,minute,second,mircosecond)
-直接创建
    datetime(2020,1,1,19,30,0,520)
    date(2020,1,1)
    time(19,30,0,520)
-获取当前时间
    获取当前日期用today，因为日期的最小计算单位是天，
    当前日期就是今天；date对象只有today一种获取当前时间的方法，
    datetime对象却有today和now两种，结果是一致的，
    time对象没有获取当前时间的方法，不过可以通过datetime对象来获取。
    datetime.now() # 获取当前日期时间
    datetime.today() # 获取当前日期时间
    date.today() # 获取当前日期
    执行结果：
    datetime.datetime(2019, 12, 31, 14, 26, 21, 655429)
    datetime.datetime(2019, 12, 31, 14, 26, 21, 658430)
    datetime.date(2019, 12, 31)

——time模块
Python 提供了一个 time 和 calendar 模块可以用于格式化日期和时间。
时间间隔是以秒为单位的浮点小数。
每个时间戳都以自从1970年1月1日午夜（历元）经过了多长时间来表示。
    -time()
        ticks = time.time()
        print('当前时间戳：', ticks)
        # 当前时间戳： 1565177767.0452278

    -获取当前时间
        localtime = time.localtime(time.time())
        print('本地时间：', localtime)
        # 本地时间： time.struct_time(tm_year=2019, tm_mon=8, tm_mday=7, \
        tm_hour=19, tm_min=43, tm_sec=14,tm_wday=2, tm_yday=219, tm_isdst=0)

    -获取格式化的时间 .asctime()
    各种格式（最简单的可读的时间模式的函数是asctime()）
        -time.asctime([t]))
            参数：t -- 9个元素的元组或者通过函数 gmtime() 或 localtime() 返回的时间值。
            返回值：返回一个可读的形式为"Tue Dec 11 18:07:14 2008"（2008年12月11日 周二18时07分14秒）的24个字符的字符              串。
            localtime = time.asctime(time.localtime(time.time()))
            print('本地时间为：', localtime)
            # 本地时间为： Wed Aug  7 20:00:40 2019

        -time.strftime(format('格式'),t)
            用time模块的strftime方法来格式化日期
            语法 time.strftime(format('格式'),t)
            # 格式化成2019-08-07 20:03:36形式
            print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime()))
            # 2019-08-07 20:04:44
            # 格式化为：Wed Aug  7 20:00:40 2019形式
            print(time.strftime('%a %b %d %H:%M:%S %Y', time.localtime()))
            # Wed Aug 07 20:07:34 2019

        -获取日历 Calendar模块
            获取某年某月的日历
            cal = calendar.month(2019, 8)
            print(cal)
                August 2019
            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

    -time.clock()
        以浮点数计算的秒数返回当前的CPU时间
        在UNIX系统上，它返回的是"进程时间"，它是用秒表示的浮点数（时间戳）。
        而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时          间。
        语法：
        time.clock()
        返回值：
        在第一次调用的时候，返回的是程序运行的实际时间；以第二次之后的调用，返回的是自第一次调用后,到这次调用的时间            间 隔

    -time.ctime(sec)
        函数把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。
        如果参数未给或者为None的时候，将会默认time.time()为参数。它的作用相当于 asctime(localtime(secs))
        print(time.ctime())
        # Wed Aug  7 20:35:38 2019

    -time.gmtime(sec)
        将一个时间戳转换为UTC时区（0时区）的struct_time，
        可选的参数sec表示从1970-1-1以来的秒数。其默认值为time.time()，函数返回time.struct_time类型的对象。
        （struct_time是在time模块中定义的表示时间的对象）。
        print(time.gmtime())
        # time.struct_time(tm_year=2019, tm_mon=8, tm_mday=7, tm_hour=12, tm_min=38, tm_sec=7,
        # tm_wday=2, tm_yday=219, tm_isdst=0)

    -time.mktime(t)
        它接收struct_time对象作为参数，返回用秒数来表示时间的浮点数。
        t = (2009, 2, 17, 17, 3, 38, 1, 48, 0)
        secs = time.mktime(t)
        print(secs)
        print(time.asctime(time.localtime(secs)))
        # 1234861418.0
        # Tue Feb 17 17:03:38 2009

    -time.sleep(t)
        t - 延迟的秒数
        print('start:', time.ctime())
        time.sleep(5)
        print('end:', time.ctime())
        # start: Wed Aug  7 20:44:37 2019
        # end: Wed Aug  7 20:44:42 2019

    -strptime(string(时间字符串), format(格式化字符))
        struct_time = time.strptime("30 Nov 00", "%d %b %y")
        print(struct_time)
        # time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0, tm_sec=0,
        # tm_wday=3, tm_yday=335, tm_isdst=-1)

——日历模块Calendar
    -a = calendar.calendar(2019, w=2, l=1, c=6)
        print(a)
        # 返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。
        # 每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数。

                                          2019

              January                   February                   March
        Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
            1  2  3  4  5  6                   1  2  3                   1  2  3
         7  8  9 10 11 12 13       4  5  6  7  8  9 10       4  5  6  7  8  9 10
        14 15 16 17 18 19 20      11 12 13 14 15 16 17      11 12 13 14 15 16 17
        21 22 23 24 25 26 27      18 19 20 21 22 23 24      18 19 20 21 22 23 24
        28 29 30 31               25 26 27 28               25 26 27 28 29 30 31

               April                      May                       June
        Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
         1  2  3  4  5  6  7             1  2  3  4  5                      1  2
         8  9 10 11 12 13 14       6  7  8  9 10 11 12       3  4  5  6  7  8  9
        15 16 17 18 19 20 21      13 14 15 16 17 18 19      10 11 12 13 14 15 16
        22 23 24 25 26 27 28      20 21 22 23 24 25 26      17 18 19 20 21 22 23
        29 30                     27 28 29 30 31            24 25 26 27 28 29 30

                July                     August                  September
        Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
         1  2  3  4  5  6  7                1  2  3  4                         1
         8  9 10 11 12 13 14       5  6  7  8  9 10 11       2  3  4  5  6  7  8
        15 16 17 18 19 20 21      12 13 14 15 16 17 18       9 10 11 12 13 14 15
        22 23 24 25 26 27 28      19 20 21 22 23 24 25      16 17 18 19 20 21 22
        29 30 31                  26 27 28 29 30 31         23 24 25 26 27 28 29
                                                            30

              October                   November                  December
        Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su      Mo Tu We Th Fr Sa Su
            1  2  3  4  5  6                   1  2  3                         1
         7  8  9 10 11 12 13       4  5  6  7  8  9 10       2  3  4  5  6  7  8
        14 15 16 17 18 19 20      11 12 13 14 15 16 17       9 10 11 12 13 14 15
        21 22 23 24 25 26 27      18 19 20 21 22 23 24      16 17 18 19 20 21 22
        28 29 30 31               25 26 27 28 29 30         23 24 25 26 27 28 29
                                                            30 31

    -calendar.firstweekday( )
        返回当前每周起始日期的设置。默认情况下，首次载入calendar模块时返回0，即星期一。
        a = calendar.firstweekday()
        print(a)
        # 0

    -calendar.isleap(year)
        是闰年返回 True，否则为 False
        print(calendar.isleap(2000))
        # True
        print(calendar.isleap(1900))
        # False

    -calendar.leapdays(y1,y2)
        返回y1，y2之间的闰年总数

    -calendar.month(year,month,w=2,l=1)
        返回一个多行字符串格式的year年month月日历，两行标题，一周一行。每日宽度间隔为w字符。每行的长度为7* w+6。l是每星期的行数。

    -calendar.monthcalendar(year,month)
        返回一个整数的单层嵌套列表。每个子列表装载代表一个星期的整数。Year年month月外的日期都设为0;范围内的日子都由该月第几日表示，从1开始。
        a = calendar.monthcalendar(2019, 8)
        print(a)
        # [[0, 0, 0, 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, 0]]

    -calendar.monthrange(year,month)
        返回两个整数。第一个是该月的星期几的日期码，第二个是该月的日期码。日从0（星期一）到6（星期日）;月从1到12。

    -calendar.prcal(year,w=2,l=1,c=6)
        print(calendar.calendar(year,w=2,l=1,c=6))
        calendar.prmonth(year,month,w=2,l=1)
        相当于 print calendar.calendar(year,month,w=2,l=1)。

    -calendar.setfirstweekday(weekday)
        设置每周的起始日期码。0（星期一）到6（星期日）。

    -calendar.timegm(tupletime)
        和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间戳（1970纪元后经过的浮点秒数）。

    -calendar.weekday(year,month,day)
        返回给定日期的日期码。0（星期一）到6（星期日）。月份为 1（一月） 到 12（12月）。

——datatime模块

    1.先导入库：import datetime
    2.获取当前日期和时间：now_time = datetime.datetime.now()
    3.格式化成我们想要的日期：strftime（）
    比如：“2016-09-21”：datetime.datetime.now().strftime('%Y-%m-%d')
    4.在当前时间增加1小时：add_hour=datetime.datetime.now()+datetime.timedelta(hours=1)   #需要导入timedelta库
    格式“小时”：now_hour=add_hour.strftime('%H')
    5.时间的三种存在方式：时间对象，时间字符串，时间戳。

    -(1)字符串转datetime：
        >>> string = '2014-01-08 11:59:58'
        >>> time1 = datetime.datetime.strptime(string,'%Y-%m-%d %H:%M:%S')
        >>> print time1
        2014-01-08 11:59:58

    -(2)datetime转字符串：
        >>> time1_str = datetime.datetime.strftime(time1,'%Y-%m-%d %H:%M:%S')
        >>> time1_str
        '2014-01-08 11:59:58'

    -(3)时间戳转时间对象：
        >>>time1 = time.localtime()
        >>>time1_str = datetime.datetime.fromtimestamp(time1)

    6.格式参数：
        %a 星期几的简写
        %A 星期几的全称
        %b 月分的简写
        %B 月份的全称
        %c 标准的日期的时间串
        %C 年份的后两位数字
        %d 十进制表示的每月的第几天
        %D 月/天/年
        %e 在两字符域中，十进制表示的每月的第几天
        %F 年-月-日
        %g 年份的后两位数字，使用基于周的年
        %G 年分，使用基于周的年
        %h 简写的月份名
        %H 24小时制的小时
        %I 12小时制的小时
        %j 十进制表示的每年的第几天
        %m 十进制表示的月份
        %M 十时制表示的分钟数
        %n 新行符
        %p 本地的AM或PM的等价显示
        %r 12小时的时间
        %R 显示小时和分钟：hh:mm
        %S 十进制的秒数
        %t 水平制表符
        %T 显示时分秒：hh:mm:ss
        %u 每周的第几天，星期一为第一天 （值从0到6，星期一为0）
        %U 第年的第几周，把星期日做为第一天（值从0到53）
        %V 每年的第几周，使用基于周的年
        %w 十进制表示的星期几（值从0到6，星期天为0）
        %W 每年的第几周，把星期一做为第一天（值从0到53）
        %x 标准的日期串
        %X 标准的时间串
        %y 不带世纪的十进制年份（值从0到99）
        %Y 带世纪部分的十制年份
        %z，%Z 时区名称，如果不能得到时区名称则返回空字符。
        %% 百分号