标准库time、datetime、calendar、random的使用
标准库time、datetime、calendar、random的使用
- 一、time模块
- 二、datetime模块
-
-
-
- datetime库概述
- datetime库解析
-
-
- 三、calendar模块
-
-
-
- calendar模块方法
- calendar.Calendar(firstweekday=0)类
- calendar.TextCalendar(firstweekday=0)
- calendar.HTMLCalendar(firstweekday=0)
-
-
- 四、random模块
一、time模块
1.时间戳：格林威治时间1970年01月01日00分00秒（北京时间1970年01月01日08时00分00秒）起至现在的总秒数。
2.元组struct_time：日期、时间是包含许多变量的，所以在Python中定义了一个元组struct_time将所有这些变量组合在一起，包括：4位数年、月、日、小时、分钟、秒等。
所有变量及要求如下：
| 属性 | 字段 | 值 |
|---|---|---|
| tm_year | 4位数年 | 2008 |
| tm_mon | 月 | 1到12 |
| tm_mday | 日 | 1到31 |
| tm_hour | 小时 | 0到23 |
| tm_min | 分钟 | 0到59 |
| tm_sec | 秒 | 0到61 (60或61 是闰秒) |
| tm_wday | 一周的第几日 | 0到6 (0是周一) |
| tm_yday | 一年的第几日 | 1到366 (儒略历) |
| tm_isdst | 夏令时 | -1, 0, 1, -1是决定是否为夏令时的旗帜 |
3.time模块的常用内置函数
(1) time.asctime([t])
将 gmtime()或localtime() 返回的表示时间的元组或struct_time转换成一个字符串，格式：‘Sun Jun 20 23:21:051993’。如果没有传入参数t，则使用localtime()返回的时间作为t。asctime()不使用时区信息。
注意：
①与同名的C函数不同，asctime()不会在输出的末尾添加一个换行符。
②这里的元组，指9个元素的元组，即与struct_time 相同格式的元组。
程序示例：
首先，使用函数gmtime()、localtime()的返回值作为参数。
>>> import time
>>> time.asctime(time.time()) #提供一个反例：time()函数返回时间戳，不能作为asctime()的参数，注意错误提示。
Traceback (most recent call last):
File "" , line 1, in <module>
time.asctime(time.time())
TypeError: Tuple or struct_time argument required # 参数只能是元组或struct_time
>>> time.asctime(time.gmtime())
'Wed Jan 10 01:03:23 2018'
>>> time.asctime(time.localtime())
'Wed Jan 10 01:09:23 2018'
然后，自定义一个9个元素的元组作为参数。为了方便检查，我们首先使用gmtime()返回一个正确的时间元组，然后将各属性值拷贝到自定义元组中：
>>> time.gmtime()
time.struct_time(tm_year=2018, tm_mon=1, tm_mday=10, tm_hour=1, tm_min=11, tm_sec=24, tm_wday=2, tm_yday=10, tm_isdst=0)
>>> tuple_time = (2018,1,10,1,11,24,2,10,0) #9个元素的元组
>>> time.asctime(tuple_time)
'Wed Jan 10 01:11:24 2018'
>>> tuple_time = (2018,10,1,1,11,24,2,10,0) #若改变元组中元素的顺序，time.asctime()将不能正确表示时间。
>>> time.asctime(tuple_time)
'Wed Oct 1 01:11:24 2018'
>>> tuple_time = (2018,10,1,1,11,24,2,10) #若元组中元素个数不等于9个，将会报错
>>> time.asctime(tuple_time)
Traceback (most recent call last):
File "" , line 1, in <module>
time.asctime(tuple_time)
TypeError: function takes exactly 9 arguments (8 given) #这里的参数提示有点歧义，应该是函数asctime()需要一个参数
#该参数中含有9个元素
>>> time.asctime(2018,10,1,1,11,24,2,10,0) #尝试错误提示中的函数需要9个参数，此时又报错。说明上面错误提示有歧义。Traceback (most recent call last):
File "" , line 1, in <module>
time.asctime(2018,10,1,1,11,24,2,10,0)
TypeError: asctime expected at most 1 arguments, got 9
(2) time.ctime([secs])
把一个时间戳（用秒计算的浮点数）转换为一个表示本地时间的字符串。如果参数secs未给出或为None，就使用由time()返回的当前时间。ctime(secs)的作用与asctime(localtime(secs))相同，只是使用方法不同而已。ctime()不使用时区信息。
注意
①ctime()、localtime()的时间戳都是使用time()获取的。
②ctime()、localtime()调用的时候都可以不传入参数，此时两者都是默认调用time()函数。
ctime()与asctime()的比较程序：
>>> import time
>>> asctime = time.asctime(time.localtime())
>>> ctime = time.ctime(time.time())
>>> asctime
'Wed Jan 10 09:43:42 2018'
>>> ctime
'Wed Jan 10 09:44:51 2018'
>>> type(asctime) #说明ctime()与asctime() 输出的内容完全相同（值相同、类型相同）。
<class 'str'>
>>> type(ctime)
<class 'str'>
ctime()与asctime()的异同点：
异：两者参数不同。ctime([secs])的参数是时间戳（常用time.time()获得），而asctime([t])的参数是时间元组（常用localtime()或gmtime()）。
同：两者输出时间的格式相同。
(3) time.gmtime()
将一个时间戳（以秒表示的时间）转换为UTC中的struct_time，其中dst标志始终为零。如果未提供secs或None，则使用由time()返回的当前时间。忽略秒的分数。有关struct_time对象的说明，请参见上文。有关此函数的逆函数，请参见calendar.timegm()。
(4) time.localtime([secs])
time.localtime([secs])与gmtime()相似，但结果是转换为本地时间。如果未提供secs或None，则使用由time()返回的当前时间。若给定时间使用的是夏令时，就将dst标志设置为1。
gmtime()与localtime()的异同点：
同：
①两者的参数相同，都是时间戳。若没有提供参数，都会自动调用time .time()得到时间戳。
②两者返回的结果格式相同，都是’Sun Jun 20 23:21:051993’ 。
异：
两者返回的时间是两个时区对相同时刻的时间表示。其中，gmtime()表示的是0时区的标准时间，而localtime()表示的是本地时区的时间。
程序举例：
>>> import time
>>> [time.gmtime(),time.localtime()] #只有tm_hour相差8个小时，其他都相同。(笔者本地采用东八区时间，相差8个时区。)
[time.struct_time(tm_year=2018, tm_mon=1, tm_mday=10, tm_hour=7, tm_min=49, tm_sec=55, tm_wday=2, tm_yday=10, tm_isdst=0), time.struct_time(tm_year=2018, tm_mon=1, tm_mday=10, tm_hour=15, tm_min=49, tm_sec=55, tm_wday=2, tm_yday=10, tm_isdst=0)]
>>> [time.asctime(time.gmtime()),time.asctime(time.localtime())] #两个时间相差8个小时。
['Wed Jan 10 07:53:35 2018', 'Wed Jan 10 15:53:35 2018']
我们平时采用的一般是函数time.localtime()。
(5) time.strftime(format[, t])
将gmtime()或localtime()返回的时间元组或struct_time转换为与参数格式相同的字符串。如果未提供t，则使用localtime()返回的当前时间。参数format[,t]必须是字符串。如果t中的任何字段超出允许范围，则会引发ValueError。
注意：
①使用函数strptime() 时，如果指令%I用于hour， 指令%p仅影响输出的hour。
②范围真的是0到61；值60在表示闰秒的时间戳中有效，且历史原因支持值61。
③当与strptime()函数一起使用时，%U和%W仅在计算中使用星期和年份指定。
>>> import time
>>> time.strftime("%Y-%m-%d %H:%M:%S",time.gmtime()) #显示时区的时间
'2018-01-10 13:10:28'
>>> time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()) #显示本地时间
'2018-01-10 21:09:45'
>>> time.strftime("%Y-%m-%d %H:%M:%S") #默认调用time.localtime()获取本地时间
'2018-01-10 21:11:19'
(6) time.strptime(string [,format] )
time.strptime(string[, format])按照格式format，解析表示时间的字符串string。返回值是struct_time类型，类似于gmtime()或localtime()。参数format使用的指令与函数strftime()所使用的相同；默认使用"%a %b %d %H:%M:%S %Y"，与ctime()返回的格式匹配。如果string不能按照format解析，或者在解析后有多余的数据存在，则会引发ValueError。
>>> import time >>> time.strptime("30 Nov 00", "%d %b %y") 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)
(7) time.time()
time.time()返回以秒为单位表示的时间。请注意，即使时间总是作为浮点数返回，但并不是所有系统都为时间提供比1秒更好的精度。虽然此函数通常返回非递减值，但如果系统时钟已在两次调用之间回退，则它可以返回比上一次调用更低的值。
通常，以此函数的获取时间戳，然后作为其他函数的输入参数。
>>> time.time()
1515592901.552844
(8) time.mktime(t)
time.mktime(t)是localtime()的反函数。Its argument is the struct_time or full 9-tuple (since the dst flag is needed; use -1 as the dst flag if it is unknown) which expresses the time in local time, not UTC. 为了与time()兼容，它返回一个浮点数。如果输入值不能表示为有效时间，则会引发OverflowError或ValueError（这取决于无效值是由Python还是基础C库）。它可以生成时间的最早日期是平台相关的。
该函数相当于函数time()的逆函数。
>>> import time
>>> [time.time(),time.localtime(time.time()),time.mktime(time.localtime(time.time()))]
[1515593108.0110633, time.struct_time(tm_year=2018, tm_mon=1, tm_mday=10, tm_hour=22, tm_min=5, tm_sec=8, tm_wday=2, tm_yday=10, tm_isdst=0), 1515593108.0]
二、datetime模块
datetime库概述
datetime库以格林威治时间为基础，每天由3 600X24秒精准定义。该库包括两个常量: datetime.MINYEAR 与datetime.MAXYEAR,分别表示datetime所能表示的最小、最大年份，值分别为1与999。
datetime库以类的方式提供多种日期和时间表达方式。
| 函数 | 描述 |
|---|---|
| datetime.date | 日期表示类，可以表示年、月、日等。 |
| datetime.time | 时间表示类，可以表示小时、分钟、秒、毫秒等。 |
| datetime.datetime | 日期和时间表示的类，功能覆盖date 和time类。 |
| datetime.timedelta | 与时间间隔有关的类。 |
| datetime.tzinfo | 与时区有关的信息表示类。 |
由于datetie.datetime类表达形式最为丰富，这里主要介绍这个类的使用。使用darctime类需要用import保留字，引用datetime类的方式如下:
from datetime import datetime
datetime库解析
datetime类( datetime.datetime类，以下简称为datetime类)的使用方式是首先创建一个datetime对象，然后通过对象的方法和属性显示时间。创建datetime 对象有3种方法: datetime.now(、 datetime.utcnow(和 datetime .datetime(。
1.使用datetime.now()获得当前日期和时间对象，使用方法如下:
datetime . now ()
作用:返回一个daetimne类型，表示当前的日期和时间，精确到微秒。参数:无
调用该函数，执行结果如下:
>>> from datetime import datetine
>>> today = datetime . now()
>>> today
datetime datetime(2016, 9, 20， 10, 29, 43，928549)
2.使用datetimne utcnow()获得当前日期和时间对应的UTC (世界标准时间)时间对象，使用方法如下:
datetime.utcnow()
作用:返回一个datetime类型，表示当前日期和时间的UTC表示，精确到微秒。参数:无
调用该函数，执行结果如下:
>>> today = datetime.utcnow()
>>> today
datetime.datetime (2016，9, 20，2，35, 1, 427954)
3.datetime.now(和datetime utcnow()都返回 个datetime类型的对象，也可以直接使用datetime0构造一个 日期和时间对象，使用方法如下:
datetime (year, month, day, hour=0, minute=0, second=0, microsecond=0)
作用:返回一个datetime类型，表示指定的日期和时间，可以精确到微秒。
| 参数 | 描述 |
|---|---|
| year | 指定的年份，MINYEAR <= year <= MAXYEARmonth:指定的月份，1 <= month <= 12 |
| day | 指定的日期，1 <= day <=月份所对应的日期上限hour:指定的小时，0 <= hour < 24 |
| minute | 指定的分钟数，0 <= minute < 60second:指定的秒数，0 <= second< 60 |
| microsecond | 指定的微秒数，0 <= microsecond <1 000000。其中，hour、minute、 second、 microsecond 参数可以全部或部分省略。 |
调用datetime(函数直接创建一个datetime 对象，表示2016年9月16日22:33,32秒7微秒，执行结果如下:
>>> someday = datetime (2016,9,16,22,33,32,7)
>>> someday
datetime.datetime (2016, 9, 16, 22, 33, 32, 7)
datetime类的常用属性
| 属性 | 描述 |
|---|---|
| somededay.min | 固定返回datetime的最小时间对象，datetime(1,1,1,0,0) |
| somededay.max | 固定返回datetime的最大时间对象，datetime(9999,12,31,23,59,59,999999 |
| somedday.year | 返回someday包含的年份 |
| someday,month | 返回someday包含的月份 |
| someday.day | 返回someday包含的日期 |
| someday.hour | 返回someday包含的小时 |
| someday.minute | 返回someday包含的分钟 |
| someday.second | 返回someday包含的秒钟 |
| Someday.microsecond | 返回someday包含的微秒值 |
datetime类的常用的格式化方法
| 属性 | 描述 |
|---|---|
| someday.isoformat() | 采用 ISO 8601 标准显示时间 |
| someday.isoweekday() | 根据日期计算星期后返回1~7，对应星期一到星期日 |
| someday.strftime(format) | 根据格式化字符串format进行格式显示的方法 |
应用如下：
>>>someday = datetime(2019,4,2,23,13,32,7)
>>>someday.isformat()
'2019-04-02T23:13:32.000007'
>>>someday.isoweekday()
2
>>>someday.strftime("%Y-%m-%d %H:%M:%S")
'2019-04-02 23:13:32'
strftime()方法的格式化控制符
| 格式符 | 说明 |
|---|---|
| %a | 星期的英文单词的缩写：如星期一， 则返回 Mon |
| %A | 星期的英文单词的全拼：如星期一，返回 Monday |
| %b | 月份的英文单词的缩写：如一月， 则返回 Jan |
| %B | 月份的引文单词的缩写：如一月， 则返回 January |
| %c | 返回datetime的字符串表示，如03/08/15 23:01:26 |
| %d | 返回的是当前时间是当前月的第几天 |
| %f | 微秒的表示： 范围: [0,999999] |
| %H | 以24小时制表示当前小时 |
| %I | 以12小时制表示当前小时 |
| %j | 返回 当天是当年的第几天 范围[001,366] |
| %m | 返回月份 范围[0,12] |
| %M | 返回分钟数 范围 [0,59] |
| %P | 返回是上午还是下午–AM or PM |
| %S | 返回秒数 范围 [0,61]。。。手册说明的 |
| %U | 返回当周是当年的第几周 以周日为第一天 |
| %W | 返回当周是当年的第几周 以周一为第一天 |
| %w | 当天在当周的天数，范围为[0, 6]，6表示星期天 |
| %x | 日期的字符串表示 ：03/08/15 |
| %X | 时间的字符串表示 ：23:22:08 |
| %y | 两个数字表示的年份 15 |
| %Y | 四个数字表示的年份 2015 |
| %z | 与utc时间的间隔 （如果是本地时间，返回空字符串） |
| %Z | 时区名称（如果是本地时间，返回空字符串） |
strftime()格式化字符串的数字左侧会自动补零
>>>from datetime import datetime
>>>now = datetime . now()
>>>now. strftime ("8Y-8m-8d")
' 2017-04-02'
>>>now.strftime("&A, &d. B 8Y &I: %M&p")' Tuesday, 02. April 2019 23:33PM'
>>>print("今天是{0:&Y}年{0:8m}月{0:%d}日" .format (now))
今天是2019年04月02日
datetime库主要用于对时间的表示，从格式化角度掌握stimn丽数已经能够处理很多情况了。建议读者在遇到需要处理时间的问题时采用daetine库，简化格式输出和时间的维护。
三、calendar模块
此模块允许输出类似Unix cal程序的日历，并提供与日历相关的其他有用功能。值得注意的是，默认情况下，这些日历将星期一作为一周的第一天，将星期日作为一周的最后一天(欧洲惯例)。不过，我们可以使用setfirstweekday()方法来设置一周的第一天为星期日或h者其他工作日，指定的日期以整数形式给出。
calendar模块主要由Calendar类与一些模块方法构成，Calendar类又衍生了一些子孙类来帮助我们实现一些特殊的功能。
calendar模块方法
1.setfirstweekday(firstweekday)：指定一周的第一天，0是星期一，…，6为星期日
import calendar
#将星期日设置为一周第一天
calendar.setfirstweekday(firstweekday=6)
2.firstweekday()：返回一周的第一天，0是星期一，…，6为星期日
import calendar
#将星期日设置为一周第一天
calendar.setfirstweekday(firstweekday=6)
print(calendar.firstweekday()) # 6
3.isleap(year)：判断指定是否是闰年，闰年为True，平年为False
import calendar
#2018年是平年，所以为False
print(calendar.isleap(2018)) # False
#2008年是如年，所以为True
print(calendar.isleap(2008)) # True
4.leapdays(y1, y2)：返回y1与y2年份之间的闰年数量，y1与y2皆为年份。包括起始年，不包括结束年：
import calendar
#2008到2011之间只有2008年是闰年，所以数量为1
print(calendar.leapdays(2008, 2011)) # 1
5.weekday(year, month, day)：获取指定日期为星期几
import calendar
#2018-08-08正是星期三，千万别忘记2代表的是星期三
print(calendar.weekday(2018, 8, 8)) # 2
6.weekheader(n)：返回包含星期的英文缩写，n表示英文缩写所占的宽度
import calendar
print(calendar.weekheader(4))
############### 打印结果如下 ###############
Mon Tue Wed Thu Fri Sat Sun
7.monthrange(year, month)：返回一个由一个月第一个天的星期与当前月的天数组成的元组
import calendar
#查看日历可以知道，08-01正是星期三，并且8月共31天
print(2018, 8) # (2, 31)
8.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]]
9.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
10.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
11.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)
############### 打印结果如下 ###############
2018
January February March April
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 4 5 6 1 2 3 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 25 26 27 28 29 30 31 29 30
May June July August
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 4 5 1 2 1 2 3 4 5 6 7 1 2 3 4
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14 5 6 7 8 9 10 11
13 14 15 16 17 18 19 10 11 12 13 14 15 16 15 16 17 18 19 20 21 12 13 14 15 16 17 18
20 21 22 23 24 25 26 17 18 19 20 21 22 23 22 23 24 25 26 27 28 19 20 21 22 23 24 25
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31 26 27 28 29 30 31
September October November December
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 1 2 3 4 5 6 1 2 3 1
2 3 4 5 6 7 8 7 8 9 10 11 12 13 4 5 6 7 8 9 10 2 3 4 5 6 7 8
9 10 11 12 13 14 15 14 15 16 17 18 19 20 11 12 13 14 15 16 17 9 10 11 12 13 14 15
16 17 18 19 20 21 22 21 22 23 24 25 26 27 18 19 20 21 22 23 24 16 17 18 19 20 21 22
23 24 25 26 27 28 29 28 29 30 31 25 26 27 28 29 30 23 24 25 26 27 28 29
30 30 31
12.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))
############### 打印结果如下 ###############
2018
January February March April
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 4 5 6 1 2 3 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 25 26 27 28 29 30 31 29 30
May June July August
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 4 5 1 2 1 2 3 4 5 6 7 1 2 3 4
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14 5 6 7 8 9 10 11
13 14 15 16 17 18 19 10 11 12 13 14 15 16 15 16 17 18 19 20 21 12 13 14 15 16 17 18
20 21 22 23 24 25 26 17 18 19 20 21 22 23 22 23 24 25 26 27 28 19 20 21 22 23 24 25
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31 26 27 28 29 30 31
September October November December
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 1 2 3 4 5 6 1 2 3 1
2 3 4 5 6 7 8 7 8 9 10 11 12 13 4 5 6 7 8 9 10 2 3 4 5 6 7 8
9 10 11 12 13 14 15 14 15 16 17 18 19 20 11 12 13 14 15 16 17 9 10 11 12 13 14 15
16 17 18 19 20 21 22 21 22 23 24 25 26 27 18 19 20 21 22 23 24 16 17 18 19 20 21 22
23 24 25 26 27 28 29 28 29 30 31 25 26 27 28 29 30 23 24 25 26 27 28 29
30
calendar.Calendar(firstweekday=0)类
firstweekday为一个整数，指定一周的第一天，0是星期一(默认)，6为星期日
1.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为星期日，即一周的第一天
2.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
````
**3.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
0
因为2018-07-29、2018-07-30、2018-07-31、2018-09-01不是指定月份的日期，所以为0
4.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正是星期三
5.monthdatescalendar(year, month)：返回一个月日期列表，按周划分，为一个二维数组。包括月份开始那周的所有日期和月份结束那周的所有日期
from calendar import Calendar
c = Calendar(firstweekday=6)
for item in c.monthdatescalendar(2018, 8):
print(item)
############### 打印结果如下 ###############
[datetime.date(2018, 7, 29), datetime.date(2018, 7, 30), datetime.date(2018, 7, 31), datetime.date(2018, 8, 1), datetime.date(2018, 8, 2), datetime.date(2018, 8, 3), datetime.date(2018, 8, 4)]
[datetime.date(2018, 8, 5), datetime.date(2018, 8, 6), datetime.date(2018, 8, 7), datetime.date(2018, 8, 8), datetime.date(2018, 8, 9), datetime.date(2018, 8, 10), datetime.date(2018, 8, 11)]
[datetime.date(2018, 8, 12), datetime.date(2018, 8, 13), datetime.date(2018, 8, 14), datetime.date(2018, 8, 15), datetime.date(2018, 8, 16), datetime.date(2018, 8, 17), datetime.date(2018, 8, 18)]
[datetime.date(2018, 8, 19), datetime.date(2018, 8, 20), datetime.date(2018, 8, 21), datetime.date(2018, 8, 22), datetime.date(2018, 8, 23), datetime.date(2018, 8, 24), datetime.date(2018, 8, 25)]
[datetime.date(2018, 8, 26), datetime.date(2018, 8, 27), datetime.date(2018, 8, 28), datetime.date(2018, 8, 29), datetime.date(2018, 8, 30), datetime.date(2018, 8, 31), datetime.date(2018, 9, 1)]
可以看出，打印出来的第一个值为第一周的日期列表，其中还包含了2018-07-29、2018-07-30、2018-07-31三天
6.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]
7.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)]
8.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),...]]]
9.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], ...]]]
10.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为星期日
1.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
2.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
3.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))
############### 打印结果如下 ###############
2018
January February March April
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 4 5 6 1 2 3 1 2 3 1 2 3 4 5 6 7
7 8 9 10 11 12 13 4 5 6 7 8 9 10 4 5 6 7 8 9 10 8 9 10 11 12 13 14
14 15 16 17 18 19 20 11 12 13 14 15 16 17 11 12 13 14 15 16 17 15 16 17 18 19 20 21
21 22 23 24 25 26 27 18 19 20 21 22 23 24 18 19 20 21 22 23 24 22 23 24 25 26 27 28
28 29 30 31 25 26 27 28 25 26 27 28 29 30 31 29 30
May June July August
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 2 3 4 5 1 2 1 2 3 4 5 6 7 1 2 3 4
6 7 8 9 10 11 12 3 4 5 6 7 8 9 8 9 10 11 12 13 14 5 6 7 8 9 10 11
13 14 15 16 17 18 19 10 11 12 13 14 15 16 15 16 17 18 19 20 21 12 13 14 15 16 17 18
20 21 22 23 24 25 26 17 18 19 20 21 22 23 22 23 24 25 26 27 28 19 20 21 22 23 24 25
27 28 29 30 31 24 25 26 27 28 29 30 29 30 31 26 27 28 29 30 31
September October November December
Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
1 1 2 3 4 5 6 1 2 3 1
2 3 4 5 6 7 8 7 8 9 10 11 12 13 4 5 6 7 8 9 10 2 3 4 5 6 7 8
9 10 11 12 13 14 15 14 15 16 17 18 19 20 11 12 13 14 15 16 17 9 10 11 12 13 14 15
16 17 18 19 20 21 22 21 22 23 24 25 26 27 18 19 20 21 22 23 24 16 17 18 19 20 21 22
23 24 25 26 27 28 29 28 29 30 31 25 26 27 28 29 30 23 24 25 26 27 28 29
30 30 31
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为星期日
1.formatmonth(theyear, themonth, withyear=Ture)：返回一个月日历的html内容，withyear是否显示年份，默认为True，即显示年份
from calendar import HTMLCalendar
c = HTMLCalendar(firstweekday=6)
print(c.formatmonth(2018, 8, withyear=False))
############### 打印结果如下 ###############
<table border="0" cellpadding="0" cellspacing="0" class="month">
<tr><th colspan="7" class="month">August</th></tr>
<tr><th class="sun">Sun</th><th class="mon">Mon</th><th class="tue">Tue</th><th class="wed">Wed</th><th class="thu">Thu</th><th class="fri">Fri</th><th class="sat">Sat</th></tr>
<tr><td class="noday"> </td><td class="noday"> </td><td class="noday"> </td><td class="wed">1</td><td class="thu">2</td><td class="fri">3</td><td class="sat">4</td></tr>
<tr><td class="sun">5</td><td class="mon">6</td><td class="tue">7</td><td class="wed">8</td><td class="thu">9</td><td class="fri">10</td><td class="sat">11</td></tr>
<tr><td class="sun">12</td><td class="mon">13</td><td class="tue">14</td><td class="wed">15</td><td class="thu">16</td><td class="fri">17</td><td class="sat">18</td></tr>
<tr><td class="sun">19</td><td class="mon">20</td><td class="tue">21</td><td class="wed">22</td><td class="thu">23</td><td class="fri">24</td><td class="sat">25</td></tr>
<tr><td class="sun">26</td><td class="mon">27</td><td class="tue">28</td><td class="wed">29</td><td class="thu">30</td><td class="fri">31</td><td class="noday"> </td></tr>
</table>
2.formatyear(theyear, width=3)：返回一年日历的html内容，width表示将12个月分为width列
from calendar import HTMLCalendar
c = HTMLCalendar(firstweekday=6)
print(c.formatyear(2018, width=4))
````
**3.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))
四、random模块
随机数在计算机应用中十分常见，Python 内置的random库主要用于产生各种分布的伪随机数序列。random库采用梅森旋转算法(MersenneTwister)生成伪随机数序列，可用于除随机性要求更高的加解密算法外的大多数工程应用。
使用random库的主要目的是生成随机数，因此，读者只需要查阅该库中随机数生成函数，找到符合使用场景的函数即可。该库提供了不同类型的随机数函数，所有函数都是基于最基本的random.random()函数扩展实现。
random库常用函数（共9个）
| 函数 | 描述 |
|---|---|
| seed(a=None) | 初始化随机数种子，默认值为当前系统时间 |
| random() | 生成一个[0.0,0.1)之间的随机小数 |
| randint(a,b) | 生成一个[a,b]之间的整数 |
| getrandbist(k) | 生成一个k比特长度的随机整数 |
| randrange(start, stop[,step]) | 生成一个[start,stop)之间以step为步数的随机整数 |
| uniform(a,b) | 生成一个[a,b]之间的随机小数 |
| choice(a,b) | 从序列类型，例如列表中随机返回一个元素 |
| shuffle(seq) | 将序列类型中的元素随机排列，返回打乱后的序列 |
| sample(pop,k) | 从pop类型中随机选取k个元素，以列表类型返回 |
random库的引用方法：import random或from random import *