time 库

基础概念

时间戳
格林威治时间1970年01月01日00分00秒（北京时间1970年01月01日08时00分00秒）起至现在的总秒数。
Python中获取时间的常用方法是，先得到时间戳，再将其转换成想要的时间格式。
元组struct_time
日期、时间是包含许多变量的，所以在Python中定义了一个元组struct_time将所有这些变量组合在一起，包括：4位数年、月、日、小时、分钟、秒等。
UTC(Coordinated Universal Time,世界协调时)
也叫格林威治天文时间，是世界标准时间．在我国为UTC+8
DST(Daylight Saving Time)
即夏令时。
一些实时函数的计算精度可能不同

变量总结如下表所示：

序号	字段	值
0	四位数年	2008
1	月	1-12
2	日	1-31
3	小时	0-23
4	分钟	0-59
5	秒	0-61 (60或61 是闰秒)
6	一周的第几日	0-6 (0是周一)
7	一年的第几日	1到366 (儒略历)
8	夏令时	-1, 0, 1, -1是决定是否为夏令时的旗帜

对应的，struct_time元组的属性如下:

序号	属性	值
0	tm_year	2008
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 (60或61 是闰秒)
6	tm_wday	0-6 (0是周一)
7	tm_yday	1到366 (儒略历)
8	tm_isdst	-1, 0, 1, -1是决定是否为夏令时的旗帜

time库函数汇总

time.altzone

返回格林威治西部的夏令时地区的偏移秒数，如果该地区在格林威治东部会返回负值(如西欧，包括英国)，对夏令时启用地区才能使用。

time.asctime([t])

接受时间元组并返回一个可读的形式"Tue May 30 17:17:30 2017"(2017年5月30日周二17时17分30秒)的24个字符的字符串。

time.clock()

用以浮点数计算的秒数返回当前的CPU时间，用来衡量不同程序的耗时，比time.time()更有用。
python3.3以后不被推荐使用，该方法依赖操作系统，建议使用per_counter(返回系统运行时间)或process_time(返回进程运行时间)代替。

time.ctime([secs])

作用相当于asctime(localtime(secs)),未给参数相当于asctime()

time.gmtime([secs])

接收时间辍(1970纪元年后经过的浮点秒数)并返回格林威治天文时间下的时间元组t(t.tm_isdst始终为０)

time.daylight

如果夏令时被定义，则该值为非零

time.localtime([secs])

接收时间辍(1970纪元年后经过的浮点秒数)并返回当地时间下的时间元组t(t.tm_isdst可取为０或１，取决于当地当时是不是夏令时)

time.mktime(t)

接受时间元组并返回时间辍(1970纪元年后经过的浮点秒数)

time.perf_counter()

返回计时器的精准时间(系统的运行时间)，包含整个系统的睡眠时间．由于返回值的基准点是未定义的，所以，只有连续调用的结果之间的差才是有效的

time.process_time()

返回当前进程执行CPU的时间总和，不包含睡眠时间．由于返回值的基准点是未定义的，所以只有连续调用的结果之间的差才是有效的

time.sleep(secs)

推迟调用线程的运行，secs的单位是秒

time.strftime(format[,t])

把一个代表时间的元组或者struct_time(如由time.localtime()和time.gmtime()返回)转化为格式化的时间字符串．如果t未指定，将传入time.localtime()，如果元组中任命一个元素越界，将会抛出ValueError异常
format格式如下：

格式	描述
%a	本地(local)简化星期名称
%A	本地完整星期名称
%b	本地简化月份名称
%B	本地完整月份名称
%c	本地相应的日期和时间表示
%d	一个月中的第几天(01-31)
%H	一天中的第几个小时(24小时制，00-23)
%l	一天中的第几个小时(12小时制，01-12)
%j	一年中的第几天(01-366)
%m	月份(01-12)
%M	分钟数(00-59)
%p	本地am或者pm的相应符
%S	秒(01-61)
%U	一年中的星期数(00-53,星期天是一个星期的开始,第一个星期天之前的所有天数都放在第０周)
%w	一个星期中的第几天(0-6,0是星期天)
%W	和%U基本相同，不同的是%W以星期一为一个星期的开始
%x	本地相应日期
%X	本地相应时间
%y	去掉世纪的年份(00-99)
%Y	完整的年份
%z	用+HHMM或者-HHMM表示距离格林威治的时区偏移(H代表十进制的小时数，M代表十进制的分钟数)
%Z	时区的名字(如果不存在为空字符)
%%	%号本身
注	%p只有与%I配合使用才有效果
*	当使用strptime()函数时，只有当在这年中的周数和天数被确定的时候%U和%W才会被计算

time.strptime(string[,format])

把一个格式化时间字符串转化为struct_time,实际上它和strftie()是逆操作

time.time()

返回当前时间的时间戳(1970元年后的浮点秒数)

time.timezone()

是当地时区(未启动夏令时)距离格林威治的偏移秒数(美洲＞０，欧洲大部分，亚洲，非洲<＝０)

time.tzname

包含两个字符串的元组，第一是当地夏令时区的名称，第二是当地的DST时区的名称

下面是找到的例子：


import time

def parse_timestr(time_str, flag=True):
    """
    把时间字符串转换为时间戳格式
    :param time_str: 时间字符串,格式为：2019-01-01 12:12:12 或 2019-01-01
    :param flag: 标志位，决定输入时间字符串的格式
    :return: 时间戳格式
    """
    if flag:
        struct_time = time.strptime(time_str, "%Y-%m-%d %H:%M:%S")  # 2019-01-01 12:12:12
    else:
        struct_time = time.strptime(time_str, "%Y-%m-%d")  # 2019-01-01
    return time.mktime(struct_time)


def parse_timestamp(time_stamp, flag=True):
    """
    把时间戳转换为时间字符串
    :param time_stamp: 时间戳
    :param flag: 标志位，可以指定输出时间字符串的格式
    :return: 时间字符串,格式为：2019-01-01 12:12:12 或 2019-01-01
    """
    localtime = time.localtime(time_stamp)
    if flag:
        time_str = time.strftime("%Y-%m-%d %H:%M:%S", localtime)
    else:
        time_str = time.strftime("%Y-%m-%d", localtime)
    return time_str


def day_range(interval_day):
    """
    获取指定天内的时间字符串的列表
    :return:
    """
    c_time = (int(time.time() / (24 * 3600)) + 1) * 24 * 3600
    day_range_str = c_time - 24 * 3600 * interval_day

    day_list = [parse_timestamp(t, flag=False) for t in range(day_range_str, c_time, 3600 * 24)]
    return day_list


def is_workday(time_str):
    """
    传入时间字符串，判断传入时间字符串是否是工作日
    :param time_str: 必须是时间字符串类型，比如："2019-01-21 14:30:31"
    :return: True/False，是否为非工作日
    """
    tmp = time.strptime(time_str, "%Y-%m-%d %H:%M:%S")
    workday_list = ["Mon", "Tue", "Wed", "Thu", "Fri"]

    week = time.strftime("%a", tmp)
    if week in workday_list:
        return True
    else:
        return False


def is_holiday(time_str):
    """
    传入时间字符串，判断传入时间字符串是否是工作日
    :param time_str: 必须是时间字符串类型，比如："2019-01-21 14:30:31"
    :return: True/False，是否为非工作日
    """
    tmp = time.strptime(time_str, "%Y-%m-%d %H:%M:%S")
    holiday_list = ["Sat", "Sun"]

    week = time.strftime("%a", tmp)
    if week in holiday_list:
        return True
    else:
        return False


def get_day_list(start_timestamp, end_timestamp, flag = True):
    """
    传入开始时间戳和结束时间戳，获取时间段内的日期列表
    :param start_timestamp: 开始时间戳
    :param end_timestamp: 结束时间戳
    :param flag: 标志位
    :return: 日期列表
    """
    tmp = range(int(start_timestamp), int(end_timestamp) + 3600, 3600 * 24)
    if flag:
        tmp_range = [{"day_str": parse_timestamp(i, flag=False)} for i in tmp]
    else:
        tmp_range = [parse_timestamp(i, flag=False) for i in tmp]
    return tmp_range


def covert_time(time_str):
    """
    把时间段转换为秒数
    :param time_str:
    :return:
    """
    if time_str.endswith("h"):
        stamp = float(time_str.strip("h")) * 3600
    elif time_str.endswith("m"):
        stamp = float(time_str.strip("m")) * 60
    else:
        stamp = float(time_str)
    return stamp

datetime库的使用

datetime模块常用的主要有下面这四个类：

datetime.date : 是指年月日构成的日期(相当于日历)
datetime.time : 是指时分秒微秒构成的一天24小时中的具体时间(相当于手表)
datetime.datetime: 上面两个合在一起，既包含时间又包含日期
datetime.timedelta: 时间间隔对象(timedelta)。一个时间点(datetime)加上一个时间间隔(timedelta)可以得到一个新的时间点(datetime)。比如今天的上午3点加上5个小时得到今天的上午8点。同理，两个时间点相减会得到一个时间间隔。

datetime.date 类

新建一个date对象，日期为今天，既可以直接调用datetime.date.today()，也可以直接向datetime.date()传值，如下：

>>>from datetime import *
>>>date.today()

datetime.date.strftime(format) 格式化为需要的时间，如常用的 “年-月-日小时：分钟：秒” 格式

>>> today.strftime('%Y-%m-%d %H:%M:%S')
>>> '2014-08-15 00:00:00’

date对象中小时、分钟、秒默认都是0，纪元年的那个时间

datetime.date.timple() 转成struct_time格式，这样传递给time.mktime(t) 后，直接转成时间戳

>>>today.timetuple()
>>>time.struct_time(tm_year=2014, tm_mon=8, tm_mday=15, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=227, tm_isdst=-1)
>>>time.mktime(today.timetuple())
>>>1408032000.0

datetime.date.replace(year, month, day) 返回一个替换后的date对象

>>> today.replace(year=2013)
>>> datetime.date(2013, 8, 15)

datetime.date.fromtimestamp(timestamp) 将时间戳转化为date对象

>>>datetime.date.fromtimestamp(1408058729)
>>>datetime.date(2014, 8, 15)

datetime.time 类

新建一个time对象

>>> t
>>> datetime.time(8, 45, 20)

datetime.time.(format)格式化输出

>>> t.strftime('%Y-%m-%d %H:%M:%S')
>>> '1900-01-01 08:45:20’

time对应的年、月、日为1900、01、01，纪元年的那个时间

datetime.time.replace([hour[, minute[, second[, microsecond[, tzinfo]]]]]) 返回一个替换后的time对象

>>> t.replace(hour=9)
>>> datetime.time(9, 45, 20)

datetime.datetime类

个人觉得和date的那些方法差不多。

新建一个datetime对象，日期为今天，既可以直接调用datetime.datetime.today()，也可以直接向datetime.datetime()传值，如下：

>>> d1 = datetime.datetime.today()
>>> d1
>>>datetime.datetime(2014, 8, 15, 8, 12, 34, 790945)
>>>d2 = datetime.datetime(2014, 8, 15, 8, 12, 34, 790945)
>>> d2
>>>datetime.datetime(2014, 8, 15, 8, 12, 34, 790945)

2.datetime.datetime.now([tz]) 当不指定时区时，和datetime.datetime.today()是一样的结果，如下

In [25]: datetime.datetime.now()
Out[25]: datetime.datetime(2014, 8, 15, 8, 14, 50, 738672)

3..datetime.datetime.strftime(format) 格式化为需要的时间，如常用的 “年-月-日 小时：分钟：秒” 格式
In [27]: d1
Out[27]: datetime.datetime(2014, 8, 15, 8, 12, 34, 790945)
In [28]: d1.strftime('%Y-%m-%d %H:%M:%S')
Out[28]: '2014-08-15 08:12:34’

4.datetime.datetime.timple() 转成struct_time格式，这样传递给time.mktime(t) 后，直接转成时间戳格式

>>> d1
>>> datetime.datetime(2014, 8, 15, 8, 12, 34, 790945)
>>>d1.timetuple()
>>> time.struct_time(tm_year=2014, tm_mon=8, tm_mday=15, tm_hour=8, tm_min=12, tm_sec=34, tm_wday=4, tm_yday=227, tm_isdst=-1)
>>> time.mktime(d1.timetuple())
>>> 1408061554.0

5.datetime.datetime.replace(year, month, day) 返回一个替换后的date对象

>>>d1
>>> datetime.datetime(2014, 8, 15, 8, 12, 34, 790945)
>>> d1.replace(year=2000)
>>> datetime.datetime(2000, 8, 15, 8, 12, 34, 790945)

datetime.datetime.fromtimestamp(timestamp) 将时间戳转化为datetime对象

>>> time.time()
>>> 1408061894.081552
>>> datetime.datetime.fromtimestamp(1408061894)
>>> datetime.datetime(2014, 8, 15, 8, 18, 14)

datetime.timedelta类

用法如下：

>>>today = datetime.datetime.today()
>>>yesterday = today - datetime.timedelta(days=1)
>>> yesterday
>>> datetime.datetime(2014, 8, 14, 15, 8, 25, 783471)
>>> today
>>> datetime.datetime(2014, 8, 15, 15, 8, 25, 783471)

calendar库的使用

calendar 模块可以以标准的模式打印出给定年月的日历。

使用calender 模块

>>>import calendar
>>>calendar.prmonth(1999, 12)
>>>
    December 1999
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

prmonth(year, month)打印给定月份的日历。

>>>import calendar
>>>calendar.prcal(2000)
>>>                                  2000

       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          1  2  3  4  5  6             1  2  3  4  5
 3  4  5  6  7  8  9       7  8  9 10 11 12 13       6  7  8  9 10 11 12
10 11 12 13 14 15 16      14 15 16 17 18 19 20      13 14 15 16 17 18 19
17 18 19 20 21 22 23      21 22 23 24 25 26 27      20 21 22 23 24 25 26
24 25 26 27 28 29 30      28 29                     27 28 29 30 31
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       1  2  3  4  5  6  7                1  2  3  4
 3  4  5  6  7  8  9       8  9 10 11 12 13 14       5  6  7  8  9 10 11
10 11 12 13 14 15 16      15 16 17 18 19 20 21      12 13 14 15 16 17 18
17 18 19 20 21 22 23      22 23 24 25 26 27 28      19 20 21 22 23 24 25
24 25 26 27 28 29 30      29 30 31                  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          1  2  3  4  5  6                   1  2  3
 3  4  5  6  7  8  9       7  8  9 10 11 12 13       4  5  6  7  8  9 10
10 11 12 13 14 15 16      14 15 16 17 18 19 20      11 12 13 14 15 16 17
17 18 19 20 21 22 23      21 22 23 24 25 26 27      18 19 20 21 22 23 24
24 25 26 27 28 29 30      28 29 30 31               25 26 27 28 29 30
31

       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             1  2  3  4  5                   1  2  3
 2  3  4  5  6  7  8       6  7  8  9 10 11 12       4  5  6  7  8  9 10
 9 10 11 12 13 14 15      13 14 15 16 17 18 19      11 12 13 14 15 16 17
16 17 18 19 20 21 22      20 21 22 23 24 25 26      18 19 20 21 22 23 24
23 24 25 26 27 28 29      27 28 29 30               25 26 27 28 29 30 31
30 31

PS:值得注意的是日历打印的格式使用的是欧洲标准，也就是说，星期一放在一周的第一天。

下面提出其他日历模块的使用方法：

calendar.calendar(year,w=2,l=1,c=6)
返回一个多行字符串格式的year年年历，3个月一行，间隔距离为c。每日宽度间隔为w字符。每行长度为21* W+18+2* C。l是每星期行数。
calendar.firstweekday( )
返回当前每周起始日期的设置。默认情况下，首次载入caendar模块时返回0，即星期一。
calendar.isleap(year)
是闰年返回True，否则为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开始。
calendar.monthrange(year,month)
返回两个整数。第一个是该月的星期几的日期码，第二个是该月的日期码。日从0（星期一）到6（星期日）;月从1到12。
calendar.prcal(year,w=2,l=1,c=6)
相当于 print calendar.calendar(year,w,l,c).
calendar.prmonth(year,month,w=2,l=1)
相当于 print calendar.calendar（year，w，l，c）。
calendar.setfirstweekday(weekday)
设置每周的起始日期码。0（星期一）到6（星期日）。
calendar.timegm(tupletime)
和time.gmtime相反：接受一个时间元组形式，返回该时刻的时间辍（1970纪元后经过的浮点秒数）。
calendar.weekday(year,month,day)
返回给定日期的日期码。0（星期一）到6（星期日）。月份为 1（一月）到 12（12月）。

random库的使用

Python中的random模块用于生成随机数。

下面具体介绍random模块的功能：

random.random()
用于生成一个0到1的随机浮点数

>>>import random  
>>>a = random.random()
>>>print (a)  
>>>0.6257592229704143

random.uniform(a,b)

用于生成一个指定范围内的随机符点数，两个参数其中一个是上限，一个是下限。如果a > b，则生成的随机数n: a <= n <= b。如果 a <b，则 b <= n <= a。

>>>import random  
>>>print(random.uniform(1,10))  
>>>print(random.uniform(10,1)) 
>>>9.374055253824894
>>>6.793063400226754

random.randint(a, b)

用于生成一个指定范围内的整数。其中参数a是下限，参数b是上限，生成的随机数n: a <= n <= b

>>>import random  
>>>print(random.randint(1,10))

random.randrange([start], stop[, step])

从指定范围内，按指定基数递增的集合中获取一个随机数。

random.randrange(10, 30, 2)，结果相当于从[10, 12, 14, 16, … 26, 28]序列中获取一个随机数。
random.randrange(10, 30, 2)在结果上与 random.choice(range(10, 30, 2) 等效。

>>>import random  
>>>print(random.randrange(10,30,2)) 
>>>18

random.choice(sequence)

random.choice从序列中获取一个随机元素。其函数原型为random.choice(sequence)。

参数sequence表示一个有序类型。
这里要说明一下：sequence在python不是一种特定的类型，而是泛指一系列的类型。list, tuple, 字符串都属于sequence。

>>>import random  
>>>lst = ['python','C','C++','javascript']  
>>>str1 = ('I love python')  
>>>print(random.choice(lst))
>>>print(random.choice(str1))  
>>>python
>>>n

random.shuffle(x[, random])

用于将一个列表中的元素打乱,即将列表内的元素随机排列。

>>>import random
>>>p = ['A' , 'B', 'C', 'D', 'E' ]
>>>random.shuffle(p)  
>>>print (p)  
>>>['B', 'D', 'E', 'C', 'A']

random.sample(sequence, k)

从指定序列中随机获取指定长度的片断并随机排列。

注意：sample函数不会修改原有序列。

>>>import random   
>>>lst = [1,2,3,4,5]  
>>>print(random.sample(lst,4))  
>>>print(lst) 
>>>[5, 3, 4, 2]
[1, 2, 3, 4, 5]

Python标准库time，datetime，calendar，random的使用

标准库time，datetime，calendar，random的使用