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

time库的使用

Python中获取时间的常用方法是，先得到时间戳，再将其转换成想要的时间格式。
时间戳：格林威治时间1970年01月01日00分00秒（北京时间1970年01月01日08时00分00秒）起至现在的总秒数。

基本方法：

time.asctime([tuple])
将一个时间元组转换成一个可读的24个时间字符串

time.asctime(time.localtime())
‘Sat Nov 12 01:19:00 2016’

time.ctime(seconds)
字符串类型返回当前时间

time.ctime()
‘Sat Nov 12 01:19:32 2016’

time.localtime([seconds])
将时间数值变换成本地时间，考虑到本地时区和夏令时标志;
(struct_timetm_year,tm_mon,tm_mday,tm_hour,tm_min,tm_sec,tm_wday,tm_yday,tm_isdst)

time.localtime() time.struct_time(tm_year=2016, tm_mon=11, tm_mday=12, tm_hour=1, tm_min=19, tm_sec=56, tm_wday=5, tm_yday=317, tm_isdst=0)

time.mktime(tuple)
将一个struct_time转换成时间戳

time.mktime(time.localtime())
1478942416.0

time.sleep(seconds)
延迟执行给定的秒数

time.sleep(1.5)

time.strftime(format[, tuple])
将元组时间转换成指定格式。[tuple]不指定默认以当前时间

time.strftime(’%Y-%m-%d %H:%M:%S’) ‘2016-11-12 01:20:54’

time.time()
返回当前时间时间戳

time.time() 1478942466.45977

time.gmtime()
返回sturct_time格式的UTC时间（0时区 格林威治天文时间 世界标准时间）

time.mktime()
将struct_time格式转换成时间戳，即将时间元组转换回时间值

time.clock()
在UNIX系统上，它返回的是“进程时间”，它是用秒表示的浮点数（时间戳）。而在WINDOWS中，第一次调用，返回的是进程运行的实际时间。而第二次之后的调用是自第一次调用以后到现在的运行时间。

time.asctime()
把一个时间的元组或者struct_time表示为‘星期 月份 日期 时：分：秒 年’。（如果没有输入参数，将会自动把time.localtime()作为参数传入）

time.strptime()
把一个格式化时间字符串转化成struct_time，与strftime()是逆操作。

time.ctime()
把一个时间戳（按秒计算的浮点数）转化为time.asctime()的形式。如果没有输入参数，默认将time.time()作为参数。
Tip：相当于time.asctime(time.localtime())

%y 两位数的年份表示（00-99）

%Y 四位数的年份表示（000-9999）

%m 月份（01-12）

%d 月内中的一天（0-31）

%H 24小时制小时数（0-23）

%I 12小时制小时数（01-12）

%M 分钟数（00=59）

%S 秒（00-59）

%a 本地简化星期名称

%A 本地完整星期名称

datetime库的使用

基于time包的一个高级包，datetime模块提供了处理日期和时间的类，既有简单的方式，又有复杂的方式。它虽然支持日期和时间算法，但其实现的重点是为输出格式化和操作提供高效的属性提取功能。可以分为三大类：date类、time类和datetime类。

获取当前日期和时间

from datetime import datetime
now=datetime.now()
print now
print (type(now))
2017-09-19 10:51:40.034996
<type ‘datetime.datetime’>

获取指定日期和时间
要指定某个日期和时间，我们直接用参数构造一个datetime：

from datetime import datetime
dt=datetime(2017,9,19,10,55)
print dt
2017-09-19 10:55:00

str转换为datetime
很多时候，用户输入的日期和时间是字符串，要处理日期和时间，首先必须把str转换为datetime。转换方法是通过datetime.strptime()实现，需要一个日期和时间的格式化字符串：

from datetime import *
cday=datetime.strptime(‘2017-1-1 18:20:20’,’%Y-%m-%d %H:%M:%S’)
print cday
2017-01-01 18:20:20

字符串’%Y-%m-%d %H:%M:%S’规定了日期和时间部分的格式。
注意转换后的datetime是没有时区信息的。

datetime转换为str
如果已经有了datetime对象，要把它格式化为字符串显示给用户，就需要转换为str，转换方法是通过strftime()实现的，同样需要一个日期和时间的格式化字符串：

from datetime import *
now=datetime.now()
print now.strftime(’%a,%b %d %H:%M’)
Tue,Sep 19 11:16

datetime加减
对日期和时间进行加减实际上就是把datetime往后或往前计算，得到新的datetime。加减可以直接用+和-运算符，不过需要导入timedelta这个类：

from datetime import datetime,timedelta
now=datetime.now()
print now
print now+timedelta(hours=10)
print now-timedelta(days=1)
print now+timedelta(days=2,hours=12)
2017-09-19 11:22:28.720470
2017-09-19 21:22:28.720470
2017-09-18 11:22:28.720470
2017-09-21 23:22:28.720470

Calendar使用

此模块允许你输出类似Unix cal程序的日历，并提供与日历相关的其他有用功能。值得注意的是，默认情况下，这些日历将星期一作为一周的第一天，将星期日作为一周的最后一天(欧洲惯例)。不过，我们可以使用setfirstweekday()方法来设置一周的第一天为星期日或h者其他工作日，指定的日期以整数形式给出。

calendar模块主要由Calendar类与一些模块方法构成，Calendar类又衍生了一些子孙类来帮助我们实现一些特殊的功能
块方法

setfirstweekday(firstweekday)：
指定一周的第一天，0是星期一，…，6为星期日

import calendar
#将星期日设置为一周第一天
calendar.setfirstweekday(firstweekday=6)

firstweekday()：
返回一周的第一天，0是星期一，…，6为星期日

import calendar
#将星期日设置为一周第一天
calendar.setfirstweekday(firstweekday=6)
print(calendar.firstweekday()) # 6

isleap(year)：
判断指定是否是闰年，闰年为True，平年为False

import calendar
#2018年是平年，所以为False
print(calendar.isleap(2018)) # False
#2008年是如年，所以为True
print(calendar.isleap(2008)) # True

leapdays(y1, y2)：
返回y1与y2年份之间的闰年数量，y1与y2皆为年份。包括起始年，不包括结束年：

import calendar
#2008到2011之间只有2008年是闰年，所以数量为1
print(calendar.leapdays(2008, 2011)) # 1

weekday(year, month, day)：
获取指定日期为星期几

import calendar
#2018-08-08正是星期三，千万别忘记2代表的是星期三
print(calendar.weekday(2018, 8, 8)) # 2

weekheader(n)：
返回包含星期的英文缩写，n表示英文缩写所占的宽度

import calendar
print(calendar.weekheader(4))

############### 打印结果如下 ###############
Mon Tue Wed Thu Fri Sat Sun

monthrange(year, month)：
返回一个由一个月第一个天的星期与当前月的天数组成的元组

import calendar
#查看日历可以知道，08-01正是星期三，并且8月共31天
print(2018, 8) # (2, 31)

monthcalendar(year, month)：
返回一个月中天数列表(不是当前月份的天数为0)，按周划分，为一个二维数组。包括月份开始那周的所有日期和月份结束那周的所有日期

import calendar
calendar.setfirstweekday(firstweekday=6)
print(calendar.monthcalendar(2018, 8))

############### 打印结果如下 ###############
[[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]]

prmonth(theyear, themonth, w=0, l=0)：
打印一个月的日历，theyear指定年份，themonth指定月份，w每个单元格宽度，默认0，内部已做处理，最小宽度为2，l每列换l行，默认为0，内部已做处理，至少换行1行

import calendar
calendar.setfirstweekday(firstweekday=6)
calendar.prmonth(2018, 8)

############### 打印结果如下 ###############
August 2018
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(theyear, themonth, w=0, l=0)：返回一个月的日历的多行文本字符串。theyear指定年份，themonth指定月份，w每个单元格宽度，默认0，内部已做处理，最小宽度为2，l每列换l行，默认为0，内部已做处理，至少换行1行

import calendar
calendar.setfirstweekday(firstweekday=6)
print(calendar.month(2018, 8))

############### 打印结果如下 ###############
August 2018
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

prcal(year, w=0, l=0, c=6, m=3)：
打印一年的日历，w每个单元格宽度，默认0，内部已做处理，最小宽度为2，l每列换l行，默认为0，内部已做处理，至少换行1行，c表示月与月之间的间隔宽度，默认为6，内部已做处理，最小宽度为2，m表示将12个月分为m列

import calendar
calendar.setfirstweekday(firstweekday=6)
calendar.prcal(2018, m=4)

calendar(year, w=2, l=1, c=6, m=3)：
以多行字符串形式返回一年的日历，w每个单元格宽度，默认2，内部已做处理，最小宽度为2，l每列换l行，默认为1，内部已做处理，至少换行1行，c表示月与月之间的间隔宽度，默认为6，内部已做处理，最小宽度为2，m表示将12个月分为m列

import calendar
calendar.setfirstweekday(firstweekday=6)
print(calendar.calendar(2018, m=4))

calendar.Calendar(firstweekday=0)类

firstweekday为一个整数，指定一周的第一天，0是星期一(默认)，6为星期日

iterweekdays()：
获取一周的数字的迭代器，迭代器的第一个值与firstweekday的值相同

<from calendar import Calendar
c = Calendar()
print(list(c.iterweekdays())) # [0, 1, 2, 3, 4, 5, 6]–>代表星期一至星期日，0为星期一，即一周的第一天
c = Calendar(firstweekday=6)
print(list(c.iterweekdays())) # [6, 0, 1, 2, 3, 4, 5]–>代表星期日至星期六，6为星期日，即一周的第一天

itermonthdates(year, month)：
获取一个月日期的迭代器，此迭代器会返回指定月份的所有日期，包括月份开始那周的所有日期和月份结束那周的所有日期

from calendar import Calendar
c = Calendar(firstweekday=6)
for item in c.itermonthdates(2018, 8):
print(item)

############### 打印结果如下 ###############
2018-07-29
2018-07-30
2018-07-31
2018-08-01
…
2018-08-31
2018-09-01

此时，我们在来看一下8月份的日期到底是怎么样的：

可以看出，2018-07-29、2018-07-30、2018-07-31正是8月份开始的那一周的日期，而2018-09-01为8月份结束的那一周的日期，8月份所有的日期全部获取得到！另外注意的是，这里的日期为datatime.date类型！另外，请将星期天设置为一周的第一天，否则将无法直观显示其作用！

itermonthdays(year, month)：
返回一个月天数的迭代器(不是当前月份的天数为0)，此迭代器将返回指定月份的日期数字，包括月份开始那周的所有日期和月份结束那周的所有日期

from calendar import Calendar
c = Calendar(firstweekday=6)
for item in c.itermonthdays(2018, 8):
print(item)

############### 打印结果如下 ###############
0
0
0
1
…
31

因为2018-07-29、2018-07-30、2018-07-31、2018-09-01不是指定月份的日期，所以为0

itermonthdays2(year, month)：返回一个月天数与星期的迭代器(不是当前月份的天数为0)，此迭代器将返回指定月份的日期数字与星期几所代表的数字组成的元组，包括月份开始那周的所有日期和月份结束那周的所有日期
from calendar import Calendar

c = Calendar(firstweekday=6)
for item in c.itermonthdays2(2018, 8):
print(item)

############### 打印结果如下 ###############
(0, 6)
(0, 0)
(0, 1)
(1, 2)
…
(31, 4)
(0, 5)

可以看出，2018-08-01正是星期三

monthdatescalendar(year, month)：
返回一个月日期列表，按周划分，为一个二维数组。包括月份开始那周的所有日期和月份结束那周的所有日期

from calendar import Calendar
c = Calendar(firstweekday=6)
for item in c.monthdatescalendar(2018, 8):
print(item)

可以看出，打印出来的第一个值为第一周的日期列表，其中还包含了2018-07-29、2018-07-30、2018-07-31三天

monthdayscalendar(year, month)：
返回一个月中天数列表(不是当前月份的天数为0)，按周划分，为一个二维数组。包括月份开始那周的所有日期和月份结束那周的所有日期

from calendar import Calendar
c = Calendar(firstweekday=6)
for item in c.monthdayscalendar(2018, 8):
print(item)

############### 打印结果如下 ###############
[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]

monthdays2calendar(year, month)：
返回一个月中天数与星期的列表(不是当前月份的天数为0)，按周划分，为一个二维数组。包括月份开始那周的所有日期和月份结束那周的所有日期

from calendar import Calendar
c = Calendar(firstweekday=6)
for item in c.monthdays2calendar(2018, 8):
print(item)

############### 打印结果如下 ###############
[(0, 6), (0, 0), (0, 1), (1, 2), (2, 3), (3, 4), (4, 5)]
[(5, 6), (6, 0), (7, 1), (8, 2), (9, 3), (10, 4), (11, 5)]
[(12, 6), (13, 0), (14, 1), (15, 2), (16, 3), (17, 4), (18, 5)]
[(19, 6), (20, 0), (21, 1), (22, 2), (23, 3), (24, 4), (25, 5)]
[(26, 6), (27, 0), (28, 1), (29, 2), (30, 3), (31, 4), (0, 5)]

yeardatescalendar(year, width=3)：
返回一年中所有的日期，为一个4维数组。width表示将一年中12个月份进行划分，每width个月为一份，每一份包含各个月份，每个月份包含周，每周包含日期信息。包括月份开始那周的所有日期和月份结束那周的所有日期

from calendar import Calendar
c = Calendar(firstweekday=6)
for item in c.yeardatescalendar(2018, 3):
print(item)

############### 打印结果如下 ###############
[[[datetime.date(2017, 12, 31), datetime.date(2018, 1, 1), datetime.date(2018, 1, 2),…]]]
[[[datetime.date(2018, 4, 1), datetime.date(2018, 4, 2), datetime.date(2018, 4, 3),…]]]
[[[datetime.date(2018, 7, 1), datetime.date(2018, 7, 2), datetime.date(2018, 7, 3),…]]]
[[[datetime.date(2018, 9, 30), datetime.date(2018, 10, 1), datetime.date(2018, 10, 2),…]]]

yeardayscalendar(year, width=3)：
返回一年中每个月的天数，为一个4维数组。width表示将一年中12个月份进行划分，每width个月为一份；每一份包含各个月份，每个月份包含周，每周包含天数信息(不是当前月份的天数为0)。包括月份开始那周的所有日期和月份结束那周的所有日期

from calendar import Calendar
c = Calendar(firstweekday=6)
for item in c.yeardayscalendar(2018, 3):
print(item)

############### 打印结果如下 ###############
[[[0, 1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12, 13], [14, 15, 16, 17, 18, 19, 20], …]]]
[[[1, 2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13, 14], [15, 16, 17, 18, 19, 20, 21], …]]]
[[[1, 2, 3, 4, 5, 6, 7], [8, 9, 10, 11, 12, 13, 14], [15, 16, 17, 18, 19, 20, 21], …]]]
[[[0, 1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12, 13], [14, 15, 16, 17, 18, 19, 20], …]]]

yeardays2calendar(year, width=3)：
返回一年中农每个月的天数与星期的元组，为一个4维的元组列表。width表示将一年中12个月份进行划分，每width个月为一份；每一份包含各个月份，每个月份包含周，每周包含天数与星期的元组信息(不是当前月份的天数为0)。包括月份开始那周的所有日期和月份结束那周的所有日期

from calendar import Calendar
c = Calendar(firstweekday=6)
for item in c.yeardays2calendar(2018, 3):
print(item)

############### 打印结果如下 ###############
[[[(0, 6), (1, 0), (2, 1), (3, 2), (4, 3), (5, 4), (6, 5)], [(7, 6), (8, 0), …]]]
[[[(1, 6), (2, 0), (3, 1), (4, 2), (5, 3), (6, 4), (7, 5)], [(8, 6), (9, 0), …]]]
[[[(1, 6), (2, 0), (3, 1), (4, 2), (5, 3), (6, 4), (7, 5)], [(8, 6), (9, 0), …]]]
[[[(0, 6), (1, 0), (2, 1), (3, 2), (4, 3), (5, 4), (6, 5)], [(7, 6), (8, 0), …]]]

calendar.TextCalendar(firstweekday=0)
Calendar子类，firstweekday为一个整数，指定一周的第一天，0是星期一(默认)，6为星期日

formatmonth(theyear, themonth, w=0, l=0)：
以多行字符串形式返回一个月的日历。theyear指定年，themonth指定月，w每个单元格宽度，默认0，内部已做处理，最小宽度为2，l每列换l行，默认为0，内部已做处理，至少换行1行

from calendar import TextCalendar
c = TextCalendar(firstweekday=6)
print(c.formatmonth(2018, 8))

############### 打印结果如下 ###############
August 2018
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

prmonth(theyear, themonth, w=0, l=0)：
打印formatmonth(theyear, themonth, w=0, l=0)的结果，无返回值

from calendar import TextCalenadr
c = TextCalendar(firstweekday=6)
c.prmonth(2018, 8)

############### 打印结果如下 ###############
August 2018
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

因为无返回值，所以返回的结果为None

formatyear(theyear, w=2, l=1, c=6, m=3)：
以多行字符串形式返回一年的日历，w每个单元格宽度，默认0，内部已做处理，最小宽度为2，l每列换l行，默认为0，内部已做处理，至少换行1行，c月与月之间的间隔宽度，默认为6，内部已做处理，最小宽度为2，m表示将12个月分为m列

from calendar import TextCalendar
c = TextCalendar(firstweekday=6)
print(c.format(2018, m=4))

pryear(theyear, w=2, l=1, c=6, m=3)：
将formatyear(theyear, w=2, l=1, c=6, m=3)的结果作为返回
calendar.HTMLCalendar(firstweekday=0)

Calendar的子类，firstweekday为一个整数，指定一周的第一天，0是星期一(默认)，6为星期日

formatmonth(theyear, themonth, withyear=Ture)：
返回一个月日历的html内容，withyear是否显示年份，默认为True，即显示年份

from calendar import HTMLCalendar
c = HTMLCalendar(firstweekday=6)
print(c.formatmonth(2018, 8, withyear=False))

############### 打印结果如下 ###############

August
Sun	Mon	Tue	Wed	Thu	Fri	Sat
			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

formatyear(theyear, width=3)：
返回一年日历的html内容，width表示将12个月分为width列

from calendar import HTMLCalendar
c = HTMLCalendar(firstweekday=6)
print(c.formatyear(2018, width=4))

formatyearpage(theyear, width=3, css=’calendar.css’, encoding=None)：
返回一年日历的html内容，width表示将12个月分为width列，css可自定义css样式，encoding编码方式

from calendar import HTMLCalendar
c = HTMLCalendar(firstweekday=6)
print(c.formatyearpage(2018, width=4))

---

作者：奔跑的豆子_
来源：CSDN
原文：https://blog.csdn.net/y472360651/article/details/82291753
版权声明：本文为博主原创文章，转载请附上博文链接！

Random的使用

random库是使用随机数的Python标准库

从概率论角度来说，随机数是随机产生的数据（比如抛硬币），但时计算机是不可能产生随机值，真正的随机数也是在特定条件下产生的确定值，只不过这些条件我们没有理解，或者超出了我们的理解范围。计算机不能产生真正的随机数，那么伪随机数也就被称为随机数

–伪随机数
计算机中通过采用梅森旋转算法生成的（伪）随机序列元素

基本随机数
Python中产生随机数使用随机数种子来产生 （只要种子相同，产生的随机序列，无论是每一个数，还是数与数之间的关系都是确定的，所以随机数种子确定了随机序列的产生）

seed(a=None)
初始化给定的随机数种子，默认为当前系统时间

random.seed(10) #产生种子10对应的序列

random()
生成一个[0.0,1.0)之间的随机小数

random.random()
0.5714025946899135 #随机数产生与种子有关，如果种子是1，第一个数必定是这个

使用随机数种子的好处是可以复现有随机数的程序

randint(a,b)
生成一个[a,b]之间的整数

random.randint(10,100)

randrange(m,n[,k])
生成一个[m,n)之间以k为步长的随机整数

random.randrange(10,100,10)

getrandbits(k)
生成一个k比特长的随机整数

random.getrandbits(16)
37885

uniform(a,b)
生成一个[a,b]之间的随机小数

random.uniform(10,100)
16.848041210321334

choice(seq)
序列相关
从序列中随机选择一个元素

random.choice([1, 2, 3, 4, 5, 6, 7, 8, 9])
8

shuffle(seq)
序列相关
将序列seq中元素随机排列,返回打乱后的序列

s=[1, 2, 3, 4, 5, 6, 7, 8, 9]; random.shuffle(s); print(s)
[9, 4, 6, 3, 5, 2, 8, 7, 1]

随机数函数的使用要点：
–能够利用随机数种子产生“确定”伪随机数 seed生成种子，random函数产生随机数
–能够产生随机整数
–能对序列类型进行随机操作

参考链接：
https://blog.csdn.net/y472360651/article/details/82291753
https://www.cnblogs.com/masked/p/8846439.html