本节内容：
1.模块的简单认识
2.collections模块（重点是，栈、队列）
3.time时间模块（时间差计算，时间戳与格式化时间的转换）
4.random模块 （获取随机数）
5.os模块
6.sys模块一、模块的简单认识
模块就是我们把装有特定功能的代买进行归类的结果。
代码编写的单位：
一条代码 < 语句块 < 代码块(函数，类) < 模块 < 包1、引入模块的方式
1.import 模块
2. from xxx import 模块二、collections模块
collections模块主要封装了一些关于集合类的相关操作1、Counter
Counter是个计数器，主要用来计数fe: 简单的示例
import collections # 一种方法 # 引入模块，模块中含有Counter
from collections import Counter # 另一种，直接在collections引入，Counter,所以可以直接使用
s = "If you have a dream, go get don't somebody can't do it."
qq = collections.Counter(s)
print(qq) # 用字典显示统计的次数
print("__iter__" in dir(qq)) # True
for item in qq:
print(item, qq[item])2、deque 双向队列； 栈、队列
双向队列之前需要先了解两种数据结构：
1、栈：FILO 特点：先进后出 --> 示例：放东西进桶，先放进去的在最下面，后放进的在上面，拿的时候先拿后面进的
2、队列：FIFO 特点：先进先出 --> 示例：银行排队，先拿到号的先办事，1、python中没有给栈（Stack)模块，手动写一个（注：此版本存在严重并发问题）
fe:自己写的一个栈
自己写一个栈,
class StackFullError(Exception): # 自定义栈满了的异常
pass
class StackEmptyError(Exception): # 自定义栈空了的异常
pass
class Stack:
def __init__(self, size): # size传入的是栈的大小
self.index = 0 # 栈顶指针
self.lst = []
self.size = size
# 给栈添加元素
def push(self, item):
if self.index == self.size:
# 栈已经满了，不能再装了，提示报错
raise StackFullError("The Stack is full")
self.lst.insert(self.index, item) # 对于空列表，需要用insert插入内容，把元素放入栈
self.index += 1 # 栈顶指针往上移一位
# 从栈中获取元素
def pop(self):
if self.index == 0:
# 栈空了，没有东西拿了，提示报错
raise StackEmptyError("The Stack is empty")
self.index -= 1 # 栈顶指针往下移一位，拿到元素出去
item = self.lst.pop(self.index) # 获取元素，删除
return item # 返回你获取的元素
s = Stack(4)
s.push("小白1")
s.push("小白2")
s.push("小白3")
s.push("小白4")
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())
print(s.pop())2、queue 队列：先进先出
注意：队列如果没有元素了，继续往外拿，会阻塞在那里fe:
import queue
q = queue.Queue() # 创建一个队列
q.put("朱棣") # 给队列添加元素
q.put("朱允炆")
q.put("朱高炽")
q.put("朱厚照")
print(q.get()) # 从队列里面拿元素出来
print(q.get())
print(q.get())
print(q.get())
print(q.get()) # 如果队列没有元素了，继续获取的话，会阻塞在这里3、 deque 双向队列
添加或修改，可以任意的从左边或者右边进行操作，此时顺序是双向的fe:
from collections import deque
q = deque() # 创建一个双向队列
q.append("高圆圆") # 从右边添加数据
q.append("佟丽娅")
q.appendleft("赵又廷") # 从左边添加数据
q.appendleft("刘大哥")
print(q.pop()) # 从右边获取数据
print(q.pop())
print(q.popleft()) # 从左边获取数据
print(q.popleft())3、nametuple 命名元组
给元组内的元素进行命名fe:
from collections import namedtuple
point = namedtuple("Point", ["x", "y"]) # 相当于写了一个类，不可变的类
# class Point: # namedtuple类似创建了这样的一个类,但是又有点特殊，不能对这个类做改动的
# def __init__(self, x, y):
# self.x = x
# self.y = y
p = point(5, 18)
print(p)
print(p.x) # 可以当成一个对象来用
# p.z = 19 # 报错 终归是个元组不可改变
# p.x = 12 # 报错4、orderdict和defaultdict
orderdict 顾名思义. 字典的key默认是⽆序的. ⽽OrderedDict是有序的1、orderdict（无序)和OrderedDict(有序）
fe:
dic = {'a':'娃哈哈', 'b':'薯条', 'c':'胡辣汤'}
print(dic) # 最底层一定是无序的. 最底层是hash
from collections import OrderedDict
# 按照我们存储的顺序保存数据
od = OrderedDict({ 'b':'薯条','a':'娃哈哈', 'c':'胡辣汤'})
print(od)2、defaultdict 给字典设置默认值
给字典设置默认值，当key不存在的时候，直接取默认值fe:
from collections import defaultdict
# d = defaultdict(list) # 参数位置，给的内容必须是可调用的
# d["周杰伦"] = "昆凌"
# print(d["周杰伦"]) # 从字典中获取数据，如果key不存在，直接获取默认值
# 运用，用来解题，将大于66的放在一个键值对里，小于的放在另外一个
# lst = [11, 22, 33, 44, 55, 66, 77, 88, 99]
# d = defaultdict(list)
#
# for el in lst:
# if el > 66:
# d["key1"].append(el) # key1是默认不存在的，但是可以拿到key1，默认是个空列表
# else:
# d["key2"].append(el)
# print(d)三、time 时间模块（重点）
时间模块是我们要熟记的. 到后⾯写程序的时候经常能⽤到.
下面三个要熟练运用：
1.time.sleep, 计时器的运用
2.时间差的计算
3.时间戳 --> 格式化时间
4.格式化时间 --> 时间戳1、概念介绍
1. 时间戳(timestamp). 时间戳使⽤的是从1970年01⽉01⽇ 00点00分00秒到现在⼀共经过了多少秒... 使⽤float来表⽰
2. 格式化时间(strftime). 这个时间可以根据我们的需要对时间进⾏任意的格式化.
3. 结构化时间(struct_time). 这个时间主要可以把时间进⾏分类划分. 比如. 1970年01⽉01⽇ 00点00分00秒 这个时间可以被细分为年, ⽉, ⽇.....⼀⼤堆东⻄.2、日期格式化的标准
%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 本地完整星期名称
%b 本地简化的⽉份名称
%B 本地完整的⽉份名称
%c 本地相应的⽇期表示和时间表示
%j 年内的⼀天（001-366）
%p 本地A.M.或P.M.的等价符
%U ⼀年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W ⼀年中的星期数（00-53）星期⼀为星期的开始
%x 本地相应的⽇期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身3、时间戳和计时器
时间戳（timestamp)：time.time() # 用float表示秒，就是一个时间点
计时器运用time.sleep() # 括号内放int类型，表示睡多少秒后再执行下一步fe:
import time
获取当前系统时间， 也叫时间戳
print(time.time()) # 1542168113.287272 给机器看的，以1970-01-01 00:00:00为基点到现在的秒数，
s = time.strftime("%Y-%m-%d %H:%M:%S") # string format time
print(s) # 打印当前时间
time.sleep(5) # 睡，隔5秒再运行， 另外的一个 wait() 一直等，需要用 notify 来唤醒才可以跳出
print("起床了")
计时器
while 1:
s = time.strftime("%Y-%m-%d %H:%M:%S") # 使用最高的时间格式
print(s)
time.sleep(1)4、时间戳与格式化的相互转换
1. 获取系统时间 time.time() 时间戳
2. 格式化时间 strftime() 常用的两种时间格式: %Y-%m-%d %H:%M:%S %Y-%m-%d
3. 结构化时间 time.gmtime() time.localtime() 结构化时间实际上是个命名元组
strptime() 把格式化时间转化成结构化时间
mktime() 把结构化时间转化成时间fe:
# 数据库里存了一个时间戳 1888888888
# 从时间戳 -> 格式化时间
t = time.localtime(1542513992) # 时区 gmtime() 格林尼治时间.
print(t)
str_time = time.strftime("%Y-%m-%d %H:%M:%S", t)
print(str_time)
# 用户输入一个时间. 变成时间戳
# 格式化时间 -> 时间戳
s = "2018-11-18 12:06:32"
t = time.strptime(s, "%Y-%m-%d %H:%M:%S") # string parse time
print(t)
# 结构化时间 -> 时间戳
ss = time.mktime(t)
print(ss)
print(time.strftime("%Y年%m月%d日"))
5、时间差的两种计算方法
1、各大语言通用的算法
时间差 1小时30分
begin = "2018-11-14 16:30:00"
end = "2018-11-14 18:00:00"
# 用时间戳计算出时间差(秒)
begin_struct_time = time.strptime(begin, "%Y-%m-%d %H:%M:%S")
end_stract_time = time.strptime(end, "%Y-%m-%d %H:%M:%S")
begin_second = time.mktime(begin_struct_time)
end_second = time.mktime(end_stract_time)
# 秒级的时间差 180000
diff_time_sec = abs(begin_second - end_second)
# 转换成分钟
diff_min = int(diff_time_sec//60)
print(diff_min)
diff_hour = diff_min//60 # 1
diff_min_1 = diff_min % 60 # 30
print("时间差是 %s小时%s分钟" % (diff_hour, diff_min_1))2、python独有的算法
begin = "2019-11-14 16:30:00"
end = "2018-11-14 18:00:00"
# 用时间戳计算出时间差(秒)
begin_struct_time = time.strptime(begin, "%Y-%m-%d %H:%M:%S")
end_stract_time = time.strptime(end, "%Y-%m-%d %H:%M:%S")
begin_second = time.mktime(begin_struct_time)
end_second = time.mktime(end_stract_time)
# 秒级的时间差 180000
diff_time_sec = abs(begin_second - end_second) # 用绝对值，就可以随便减
# 转化成结构化时间
t = time.gmtime(diff_time_sec) # 最好用格林尼治时间。 否则有时差
print(t)
print("时间差是%s年%s月 %s天 %s小时%s分钟" % (t.tm_year-1970, t.tm_mon-1, t.tm_mday-1,t.tm_hour, t.tm_min ))四、random模块
所有关于随机相关的内容都在random模块中.fe:示例
import random
print(random.randint(1,2)) # [start, end]
print(random.random()) # (0,1)之间的小数
print(random.uniform(3,10)) # （3， 10 ）的随机小数
n = random.randrange(1, 10, 3) # [1, 10) 从奇数中获取到随机数
print(random.choice([1, "小白", ["疏影", "暗香", "清浅"]])) # 随机从[1, "小白", ["疏影", "暗香", "清浅"]]中获取一个
print(random.sample([1, '23', [4, 5]], 2)) # （list,2) 列表元素任意2个组合
lst = ["周杰伦", "昆凌", "马化腾", "马丽", "沈腾", "秋雅"]
random.shuffle(lst) # 随机打乱顺序
print(lst)五、os模块
所有和操作系统相关的内容都在os模块
重点：
os.sep 文件路径分隔符
sys.path python查找模块的路径1、os相关操作
# 常用版
os.makedirs('dirname1/dirname5') # 创建文件夹目录结构
os.removedirs('dirname1/dirname5') # 删除文件夹, 如果文件夹内没有东西。 就可以删除。 否则报错
os.mkdir('dirname/哈哈') # mkdir如果父级目录不存在。 报错
os.rmdir('dirname') # 删除文件夹
print(os.listdir('../')) # 获取到文件夹内的所有内容. 递归
print(os.stat('dirname')) # linux
os.system("dir") # 直接执行命令行程序
s = os.popen("dir").read()
print(s)
print(os.getcwd() ) # 当前程序所在的文件夹
print(os.path.abspath("../day020 继承") ) # 获取绝对路径
print(os.path.split("D:python_workspaceday020 继承")) # 拆分路径 ('D:\python_workspace', 'day020 继承')
print(os.path.dirname("D:python_workspaceday020 继承")) # D:python_workspace
print(os.path.basename("D:python_workspaceday020 继承")) # day020 继承
print(os.path.exists("dirname")) # 判断文件是否存在
print(os.path.isabs("D:python_workspaceday020 继承")) # 是否是绝对路径
print(os.path.isfile("01 今日主要内容")) # 是否是文件
print(os.path.isdir("dirname")) # 是否是文件夹
print(os.path.getsize("01 今日主要内容") ) # 文件大小
print("胡辣汤", "传盛", "big", sep="small")
print("c:"+os.sep+"胡辣汤") # \/ 文件路径的分隔符
# 详细版
os.makedirs('dirname1/dirname2') 可⽣成多层递归⽬录
os.removedirs('dirname1') 若⽬录为空，则删除，并递归到上⼀级⽬录，如若也为空，则删
除，依此类推
os.mkdir('dirname') ⽣成单级⽬录；相当于shell中mkdir dirname
os.rmdir('dirname') 删除单级空⽬录，若⽬录不为空则⽆法删除，报错；相当于shell中
rmdir dirname
os.listdir('dirname') 列出指定⽬录下的所有⽂件和⼦⽬录，包括隐藏⽂件，并以列表⽅式
打印
os.remove() 删除⼀个⽂件
os.rename("oldname","newname") 重命名⽂件/⽬录
os.stat('path/filename') 获取⽂件/⽬录信息
os.system("bash command") 运⾏shell命令，直接显示
os.popen("bash command).read() 运⾏shell命令，获取执⾏结果
os.getcwd() 获取当前⼯作⽬录，即当前python脚本⼯作的⽬录路径
os.chdir("dirname") 改变当前脚本⼯作⽬录；相当于shell下cd
# os.path
os.path.abspath(path) 返回path规范化的绝对路径
os.path.split(path) 将path分割成⽬录和⽂件名⼆元组返回
os.path.dirname(path) 返回path的⽬录。其实就是os.path.split(path)的第⼀个元素
os.path.basename(path) 返回path最后的⽂件名。如何path以／或结尾，那么就会返回空值。
即os.path.split(path)的第⼆个元素
os.path.exists(path) 如果path存在，返回