python 17 内置模块

目录

• 1. 序列化模块
  • 1.1 json 模块
    • 1.1.1 dumps、loads
    • 1.1.2 dump、loads
    • 1.1.3 同时写/读多个内容
  • 1.2 pickle 模块
    • 1.2.1 dumps、loads
    • 1.2.2 dump、load
    • 1.2.3 同时写/读多个内容
• 2. os 模块
• 3. sys 模块
• 4. hashlib 加密、摘要
  • 4.1 加密
  • 4.2 加盐
    • 4.2.1 固定加盐
    • 4.2.3 动态加盐
  • 4.3 文件一致性校验
• 5. collections 模块
  • 5.1 Counte 统计(***)
  • 5.2 namedtuple 命名元组
  • 5.3 deque 双端队列
  • 5.4 defaultdict 带有默认值的字典
  • 5.5 OrderedDict 有序字典

1. 序列化模块

1.1 json 模块

1. 不同语言都遵循的一种数据转化格式，即不同语言都使用的特殊字符串。
2. json序列化只支持部分Python数据结构：dict,list,tuple,str,int, float,True,False,None

json模块是将满足条件的数据结构转化成特殊的字符串，并且也可以反序列化还原回去

​ 用于网络传输：dumps、loads
​ 用于文件写读：dump、load

1.1.1 dumps、loads

import json
lst = [1,2,3,4,5,6]
str_lst = json.dumps(lst)
print(str_lst,type(str_lst))  # 将列表转换成字符串
	# [1, 2, 3, 4, 5, 6] <class 'str'>

list_lst = json.loads(str_lst)
print(list_lst,type(list_lst)) # 将字符串转换成列表
	# [1, 2, 3, 4, 5, 6] <class 'list'>

# 总结：
dumps:将对象转换（序列化）成字符串
loads:将字符串转换（反序列化）成对象

1.1.2 dump、loads

import json
lst = [1,2,3,4,5]
f = open("info","a",encoding="utf-8")
json.dump(lst,f)  # 将列表写入文件中
f.close()

f = open("info","r",encoding="utf-8")
f1 = json.load(f)
print(f1, type(f1))   # 将文件中的字符串转换成列表

# 总结：
json.dump(对象，文件句柄):将对象转换（序列化）成字符串写入文件；
json.load(文件句柄):将文件的字符串读取转换（反序列化）成对象。

1.1.3 同时写/读多个内容

# 写
lst = [1,2,3,4,5]
f = open("info","a+",encoding="utf-8")
f.write(json.dumps(lst)+"\n")
f.write(json.dumps(lst)+"\n")
f.write(json.dumps(lst)+"\n")
f.close()

# 读
f1 = open("info","r",encoding="utf-8")
for i in f1:
    s = json.loads(i)
    print(s,type(s))
	# [1, 2, 3, 4, 5] <class 'list'>

1.2 pickle 模块

pickle：序列化，将python所有对象进行转换，是python自带的，不能用于其他语言。

1.2.1 dumps、loads

import pickle
lst = [1,2,3,4,5]
t_lst = pickle.dumps(lst)  # 将列表转换成类字节
print(t_lst) #b'\x80\x03]q\x00(K\x01K\x02K\x03K\x04K\x05e.'

li = pickle.loads(t_lst)  #将类字节转换成列表
print(li,type(li))
# [1, 2, 3, 4, 5] <class 'list'>

# 总结：
dumps:将对象转换成类字节；
loads:将类字节转换成对象。

1.2.2 dump、load

import pickle
dic = {"name":"alex"}
pickle.dump(dic,open("info","wb"))  # 字典转换成类字节写入文件
print(pickle.load(open("info","rb"))) # 从文件读取并转换成字典

# 总结
pickle.dump(对象，文件句柄):将对象转换（序列化）成类字节写入文件；
pickle.load(文件句柄):将文件的类字节读取转换（反序列化）成对象

1.2.3 同时写/读多个内容

import pickle
dic = {"a":1,"b"=2}
f = open("info","wb")
s = "\n".encode("utf-8")
f.write(pickle.dumps(dic)+ s)
f.write(pickle.dumps(dic)+ s)
f.write(pickle.dumps(dic)+ s)
f.close()

# 从文件读
f1 = open("info","rb")
for i in f1:
    print(pickle.loads(i))

2. os 模块

程序员通过python向操作系统发送指令（与操作系统交互的接口）。

# 1.工作目录：
os.getcwd() # 当前文件的工作目录路径  ***
os.chdir("F:\s24\day06") # 工作目录路径切换
print(os.curdir)  # 当前级
print(os.pardir)  # 父级

# 2.文件夹 ***
os.mkdir("文件夹名") # 创建一个文件夹
os.rmdir("文件夹名") # 删除一个文件夹
os.makedirs("ttt/sss/ddd/ee")  # 递归创建文件夹
os.removedirs("ttt/sss/ddd/ee")  # 递归删除文件夹
os.listdir(r"F:\s24\day17") # 将路径下所有文件名按列表打印

# 3.文件
os.rename()  # 修改名字
os.remove("文件名")  # 删除文件

# 4.路径 os.path
***
os.path.abspath(r"01 今日内容.py") # 通过相对路径获取绝对路径
os.path.split(r"F:\s24\day17\01 今日内容.py") # 将路径以最后一个\切割(路径,文件名)
os.path.dirname(r"F:\s24\day17\01 今日内容.py") #只获取路径（没有后面的文件名）
os.path.basename(r"F:\s24\day17\01 今日内容.py") #只获取文件名
os.path.exists("路径")  # 判断这个路径是否存在
os.path.isdir(r"F:\s24\day17")   # 判断是不是工作目录（路径）（不能有文件名）
os.path.isfile(r"01 今日内容.py")  # 判断是不是文件
os.path.isabs(r"F:\s24\day17\01 今日内容.py")   # 判断是不是绝对路径
os.path.join("D:\\","ttt","bbb") # 路径拼接 *****
os.path.getatime(r"F:\s24\day17\04 序列化.py")  # 查看文件最后的修改时间
os.path.getsize(r"F:\s24\day09")     # 获取当前文件/文件夹的大小

**
os.path.getctime(r"F:\s24\day17\04 序列化.py")     # 查看文件最后的访问时间
os.path.getmtime(r"F:\s24\day17\04 序列化.py")     # 查看文件最后的访问时间

3. sys 模块

与python解释器交互的接口。

***
sys.argv   # 当前文件运行  ['D:/S24/Day 17/1.py']
	# 命令行参数List，第一个元素是程序本身路径;当做脚本执行的时候能够携带参数
sys.path   #返回模块的搜索路径（列表），初始化时使用pythonpath环境变量的值

**
sys.exit(n)   # 退出程序，正常退出时exit(0),错误退出sys.exit(1),可修改
sys.version   # 获取解释器版本
sys.platform  # 返回操作系统平台名称

4. hashlib 加密、摘要

4.1 加密

作用：加密和校验

四种：md5 、 sha1 、 sha256 、 sha512
1.只要明文相同，密文就是相同的；
2.只要明文不相同，密文就是不相同的；
3.不能反逆（不能解密）--md5被中国人破解

# 加密：1.加密的内容；2.将要加密的内容转换成字节

# md5加密:
import hashlib
md5 = hashlib.md5()   # 初始MD5
md5.update("加密内容"，encode("编码集"))   #放内容，编码集可随意
print(md5.hexdigest())		# 合成 输出

# 其他方法，字节较长，算法越高，转化成的结果越复杂，安全程度越高，相应的效率就会越低。

# 最常用的是md5，平时加密的时候sha1

4.2 加盐

4.2.1 固定加盐

import hashlib
md5 = hashlib.md5('学习'.encode('utf-8'))  # 学习就是固定的盐
md5.update('a'.encode('utf-8'))
print(md5.hexdigest())

4.2.3 动态加盐

user = input("请输入账号：")
pwd = input("请输入密码：")
import hashlib
md5 = hashlib.md5(user.encode('utf-8'))  # user每次都变
md5.update(pwd.encode('utf-8'))
print(md5.hexdigest())

4.3 文件一致性校验

   '''下载一个软件时，往往都带有一个MD5或者shax值，当下载完成这个应用程序时你要是对比大小根本看不出什么问题，应该对比它们的md5值，如果两个md5值相同，就证明这个应用程序是安全的，如果你下载的这个文件的MD5值与服务端给你提供的不同，那么就证明你这个应用程序肯定是植入病毒了（文件损坏的几率很低），那么应该赶紧删除。'''

# python-3.6.6-amd64.exe 文件检验
f = open(r"F:\s24\day17\python-3.6.6-amd64.exe","rb")
import hashlib
md5 = hashlib.md5()
while True:
    msg = f.read(1024)
    if msg:
        md5.update(msg)
    else:
        print(md5.hexdigest())
        break
# 767db14ed07b245e24e10785f9d28e29   结果一样说明ok的

5. collections 模块

5.1 Counte 统计(***)

from collections import Counter
s = [1,1,2,2,3,3]
print(dict(Counter(s)))  # {1: 2, 2: 2, 3: 2}

s1 = ("a",2,3,3,"a",2,"a",1,"a")
print(dict(Counter(s1))) # {'a': 4, 2: 2, 3: 2, 1: 1}
# 统计元素出现的次数,以字典的形式输出

5.2 namedtuple 命名元组

# 生成可以使用名字来访问元素内容的tuple
namedtuple('名称', [属性list])

from collections import namedtuple
Point = namedtuple('Point', ['x', 'y'])
p = Point(1, 2)
print(p)   		# Point(x=1, y=2)

5.3 deque 双端队列

# 双端队列，可以快速的从另外一侧追加和推出对象

lst = deque([1,2,3,4,5,6,7])
lst.append(8)   # 末尾增加
lst.appendleft(0) # 首加
lst.pop()		# 末尾删除
lst.popleft()	# 首删

5.4 defaultdict 带有默认值的字典

 # 带有默认值的字典
from collections import defaultdict
dic = defaultdict(list)    	# 定义字典值数据类型list
dic["key1"].append(12)		# 将值添加到列表中，键为key1
print(dic)   # {'key1': [12]}

# 将所有大于 66 的值保存至字典的第一个key中，将小于 66 的值保存至第二个key的值中。
from collections import defaultdict
values = [11, 22, 33,44,55,66,77,88,99,90]
my_dict = defaultdict(list)

for value in  values:
    if value>66:
        my_dict['k1'].append(value)
    else:
        my_dict['k2'].append(value)

5.5 OrderedDict 有序字典

from collections import OrderedDict
od = OrderedDict([])
od["z"] = 1
od["y"] = 2
od["x"] = 3
print(od)    # OrderedDict([('z', 1), ('y', 2), ('x', 3)]) 会按照插入的顺序排列