常用模块的介绍

1.collections模块

　　在以下内置数据类型中 能使用：dict(字典)、list(列表)、set(集合)、tuple(元组)、布尔值等。

1.namedtuple(具名元组) 　　 # namedtuple = ('名称'，[属性list])

 

#先表示坐标点x为1，y为2，z为3
from collections import namedtuple    # 从集合导入名字复制
point = namedtuple('坐标',['x','y','z'])#第一个是类名，第二个参数既可以传可迭代对象
point = namedtuple('坐标','x y z')#也可以传字符串，但是字符串里面要以空格隔开
p = point(1,2,3)
print(p)#>>>:坐标(x=1, y=2, z=3)
print(p.x)#>>>:1
print(p.y)#>>>:2
print(p.z)#>>>:3

2. deque

　　deque是为了高效实现插入和删除操作的双向列表，适用于队列和栈

# 队列：先进先出
import queue
q = queue.Queue()#生成队列对象
q.put('first')#往队列中添加值
q.put('second')
print(q.get())#找队列要值#>>>:firet
print(q.get())#>>>:second
print(q.get())#如果队列中的值取完了，程序会在原地等待，直到从队列中拿到值才停止

#q = queue.LifoQueue() 堆栈，后进先出

　　deque除了实现list 的append()和pop()外，还支持appendleft()和popleft()，可以高效的往头部添加或者删除元素。双向队列可以根据索引在任意位置插值。

3.OrderedDict

　　当使用dic时，key是无序的。在对dict做迭代时 ，我们无法确定key的顺序。如果此时想要保持key的顺序，可以用OrderedDict

from collections import OrderedDict
d = dict([('a',1),('b',2),('c',3),('d',4)])
print(d) #dict中的key是
>>>:{'a': 1, 'b': 2, 'c': 3, 'd': 4}
d1 = OrderedDict([('a',1),('b',2),('c',3),('d',4)])
print(d1)   #OrderedDict中的key是有序的
>>>:OrderedDict([('a', 1), ('b', 2), ('c', 3), ('d', 4)])
补充OrderedDict中的key会按照插入的顺序排列，不是key本身可以排序。

4.defaultdict

　　当所引用的key不存在，如果是使用dict，就会出现KeyError；如果是用defaultdict，就会返回一个默认值。  

#有集合 [11,22,33,44,55,66,77,88,99]，将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
#defaultdict字典解释用法
from collections import defaultdict
values = [11, 22, 33, 44, 55, 66, 77, 88, 99]
my_dict = defaultdict(list)
for value in values:
    if value > 66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)
print(my_dict)

5.Counter

　　Counter类的目的是用来追踪值所出现的次数。它是一个无序的容器类型，以字典的键值对形式来存储，其中袁术作为key，其出现的次数作为value。

from collections import Counter
c = Counter('sfdabaa;a;ssadf')
print(c)
>>>:Counter({'a': 5, 's': 3, 'f': 2, 'd': 2, ';': 2, 'b': 1})

2.时间模块

表示时间的三种方式：

1.时间戳（timestamp）

通常是指从1970年1月1日00:00:00开始按秒计算的偏差值。我们运行“type(time.time())”,返回是float类型。

2.格式化的时间字符串（Format String）

3.结构化时间（struct_time）

import time      #导入时间模块
print(time.time())#时间戳
>>>:1563448751.5440147
print(time.strftime('%Y-%m-%d %X'))#时间字符串
>>>:2019-07-18 19:19:11
print(time.strftime('%Y-%m-%d %H:%M:%S'))#显示出年月日时分秒，与上一个等价
>>>:2019-07-18 19:19:11
print(time.localtime())#时间元组
>>>:time.struct_time(tm_year=2019, tm_mon=7, tm_mday=18, tm_hour=19, tm_min=19, tm_sec=11, tm_wday=3, tm_yday=199, tm_isdst=0)
补充：时间戳是计算机能够识别的语言：时间字符串是人能够看懂的时间；时间元组就是用来操作时间的。

 3.random模块

import random#导入random模块
#随机小数
print(random.random())#取0到1之间的小数>>>:0.9977039618497414
print(random.uniform(1,5))#取1到5之间的小数
>>>:1.0704315014777674

#随机整数
print(random.randint(1,5))#取1到5之间的整数，包括1和5
>>>:2
print(random.randrange(1,11,3))#取1到11之间，比1多3n的数，包括1.如1,4,7,10
>>>:1

print(random.choice([1,'23',[4,5],{666}]))#随机选一个返回
>>>:{666}
print(random.sample([1,'23',[4,5],{112}],2))#随机从列表中选取两个任意组合
>>>:[1, {112}]

#打乱顺序
item = [1,3,5,7,9]
random.shuffle(item)#打乱列表顺序
print(item)
>>>:[1, 7, 3, 5, 9]

#练习：随机生成验证码
import random
def get_code(n):
    code = ''
    for i in range(n):
        # 先生成随机的大写字母，小写字母，数字
        upper_str = chr(random.randint(65,90))
        lower_str = chr(random.randint(97,122))
        random_int = str(random.randint(0,9))
        # 从上面三个中随机选择一个座位随机验证码的某一位
        code += random.choice([upper_str,lower_str,random_int])
    return code
res = get_code(4)
print(res)

4.os模块

os模块是与操作系统交互的一个接口

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存在，返回True；如果path不存在，返回False
os.path.isabs(path)  如果path是绝对路径，返回True
os.path.isfile(path)  如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(path)  如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1[, path2[, ...]])  将多个路径组合后返回，第一个绝对路径之前的参数将被忽略
os.path.getatime(path)  返回path所指向的文件或者目录的最后访问时间
os.path.getmtime(path)  返回path所指向的文件或者目录的最后修改时间
os.path.getsize(path) 返回path的大小

5.sys模块

sys模块是与python解释器交互的一个接口

import sys
sys.path.append()  # 将某个路径添加到系统的环境变量中
print(sys.platform)
print(sys.version)  # python解释器的版本

print(sys.argv)  # 命令行启动文件 可以做身份的验证
if len(sys.argv) <= 1:
    print('请输入用户名和密码')
else:
    username = sys.argv[1]
    password = sys.argv[2]
    if username == 'li' and password == '123':
        print('欢迎使用')
        # 当前这个py文件逻辑代码
    else:
        print('用户不存在 无法执行当前文件')

6.序列化模块

　　序列化就是将原本的字典，列表等数据类型转换成一个字符串的过程。其中写入文件的数据必须要是字符串，而且基于网络传输的数据必须是二进制。

1.序列化的目的

（1）以某种存储形式使自定义对象持久化；

（2）将对象从一个地方传递到另一个地方。

（3）使程序更具有维护性。

2.json模块

优点：所有语言都支持json格式。缺点：支持的数据类型很少，有字符串，列表，字典，整型，元组，布尔值。

dumps与loads
import json
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic)#序列化：将一个字典转换成一个字符串
print(type(str_dic),str_dic)
>>>:<class 'str'> {"k1": "v1", "k2": "v2", "k3": "v3"}
# 注意：json转换完的字符串类型中，字典中的字符串是由" "表示的

dic2 = json.loads(str_dic)#反序列化：将一个字符串格式的字典装换为一个新字典
print(type(dic2),dic2)
#注意，要用json的loads功能处理的字符串类型的字典中的字符串必须由""表示
>>>:<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
补充：dumps也可以处理嵌套的数据类型

import json
f = open('json_file','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f)  #dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
f.close()

f = open('json_file')
dic2 = json.load(f)  #load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
f.close()
print(type(dic2),dic2)

3.pickle模块

缺点：只支持python。优点：python所有的数据类型都支持。

注意：用pickle操作文件的时候，文件的打开模式必须是b模式

import pickle
d = {'name':'li'}
res = pickle.dumps(d)  # 将对象直接转成二进制
print(pickle.dumps(d))
>>>:b'\x80\x03}q\x00X\x04\x00\x00\x00nameq\x01X\x02\x00\x00\x00liq\x02s.'
res1 = pickle.loads(res) #将二进制再转回来
print(res1,type(res1))
>>>:{'name': 'li'} <class 'dict'>