python3--序列化模块,hashlib模块
内置方法(回顾)
__len__ len(obj)的结果依赖于obj.__len__()的结果，计算对象的长度
__hash__ hash(obj)的结果依赖于obj.__hash__()的结果，计算对象的hash值
__eq__ obj1 == obj2的结果依赖于obj.__eq__()的结果，用来判断值相等
__str__ str(obj) print(obj) '%s'%obj 的结果依赖于__str__,用来做输出，显示
__repr__ repr(obj) '%r'%obj 的结果依赖于__repr__,还可以做str的备胎
__format__ format()的结果依赖于__format__的结果，是对象格式化
__call__ obj()相当于调用__call__,实现了__call__的对象是callable的
__new__ 构造方法，在执行__init__之前执行，负责创建一个对象，在单例模式中有具体的应用
__del__ 析构方法，在对象删除的时候，删除这个对象之前执行，主要用来关闭在对象中打开的系统资源
单例模式：只有一个对象，只开了一个内存空间
python中的单例模式，是依赖__new__来完成的
class A:
def __getitem__(self, item):
print(item)
a = A()
a['bbb'] # 对象['值']触发了__getitem__
#__getitem__ 对象[]的形式对对象进行增删改查
# __setitem__
# __delitem__
# __delattr__ del obj.attr 用来自定义删除一个属性的方法
面试题
写一个类，定义100个对象
拥有三个属性name age sex
如果两个对象的name 和 sex 完全相同，就认为这是同一个对象，忽略age属性
做这100个对象的去重
需用用到的知识点
hash算法 一个值 进行一系列的计算得出一个数字，让每一个不同的值计算出的数字都不相等
class Person:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
def __hash__(self):
# hash算法本身就存在了 且直接在python中就能调用
# 姓名相同 性别相同的对象的hash值应该相等才行
return hash(self.name+self.sex)
def __eq__(self, other):
if self.name == other.name and self.sex == other.sex:return True
p_lst1 = []
for i in range(98):
p_lst1.append(Person('egon' + str(i),i,'man'))
p_lst1.append(Person('egon50',200,'man'))
p_lst1.append(Person('egon51',300,'man'))
print(len(p_lst1))
# set对一个对象序列的去重，依赖于这个对象的两个方法: hash eq
print(len(set(p_lst1)))执行结果
98
set对一个对象序列的去重，依赖于这个对象的两个方法: hash eq
key hash 数字 --> 内存地址 --> value
set hash 数字 --> 内存地址 --> set中的元素
如果值存在，则覆盖
set对一个对象序列的去重，如何判断这两个值是否相等
值a进行hash --> 存值
值b进行hash --> 判断值是否：相等 --> 说明是一样的
值b进行hash --> 判断值是否: 不相等 --> 在开辟一个空间，来存放b
python常用模块！！
什么叫序列化---将原本的字典，列表等内容转换成一个字符串的过程叫做序列化。
在python代码中计算的一个数据需要给另外一段程序使用，那我们怎么给?现在能想到的方法就是存在文件里，然后另一个python程序再从文件里读出来,很麻烦!
序列化的目的
1 以某种存储形式使自定义对象持久化
2 将对象从一个地方传递到另一个地方
3 使程序更具维护性
python中的序列化模块
json 所有的编程语言都通用的序列化格式，它支持的数据类型非常有限：数字，字符串，列表，字典
pickle 只能在python语言的程序之间传递数据用的，pickle支持python中所有的数据类型
shelve python3.*之后才有的
序列化的使用场景：
1 能存储在文件中的一定是字符串 或者是 字节
2 能在网络上传输的 只有字节
json
json模块提供了四个功能:dumps,dump,loads,load
序列化：dumps 示例
import json
dic = {'张三': (175, 70, '开车')}
ret = json.dumps(dic) # 序列化：将一个字典转换成一个字符串
print(type(dic), dic) # 打印字典类型,内容
print(type(ret), ret) # 打印序列化后的类型，内容
# 注意，json转换完的字符串类型的字典中的字符串是由""双引号表示执行结果
反序列化：loads 示例
# 反序列化,变成原来的类型
import json
dic = {'张三': (175, 70, '开车')}
ret = json.dumps(dic) # dumps序列化
res = json.loads(ret) # loads反序列化
print(type(res), res)执行结果
dump方法接收一个文件句柄，直接将字典转换成json字符串写入文件
示例
import json
dic = {'张三': (175, 70, '开车')}
f = open('userinfo', 'w', encoding='utf-8')
# 先接收要序列化的对象，在接收文件句柄
json.dump(dic, f, ensure_ascii=False) # 加上ensure_ascii=False，显示中文
f.close()直接结果，打开文件看
load方法接收一个文件句柄，直接将文件中的json字符串转换成数据结构返回
import json
dic = {'张三': (175, 70, '开车')}
f = open('userinfo', 'r', encoding='utf-8')
ret = json.load(f)
print(ret)
f.close()执行结果
{'张三': [175, 70, '开车']}
json个性化输出
import json
data = {'username':['李华','二愣子'],'sex':'male','age':16}
json_dic2 = json.dumps(data,sort_keys=True,indent=2,separators=(',',':'),ensure_ascii=False)
# sort_keys 对每一个元素，做了排序
# indent 表示空白数，控制缩进
# separatots 分隔符
# ensure_ascii=False 不适用ascii编码显示
print(json_dic2)执行结果
{
"age":16,
"sex":"male",
"username":[
"李华",
"二愣子"
]
}
如果有多个字典，用json如何写入？
错误示例
import json
dic1 = {'张三': (175, 70, '开车')}
dic2 = {'李四': (170, 60, '旅游')}
dic3 = {'王五': (190, 80, '唱歌')}
f = open('user_info', 'a', encoding='utf-8')
json.dump(dic1, f, ensure_ascii=False) # json.dump写进文件
json.dump(dic2, f, ensure_ascii=False)
json.dump(dic3, f, ensure_ascii=False)
f.close()
# json.load读取文件数据
f1 = open('user_info', 'r', encoding='utf-8')
print(json.load(f1))
f1.close()执行报错，读取文件时报错
json.decoder.JSONDecodeError: Extra data: line 1 column 24 (char 23)
正确方法
import json
dic1 = {'张三': (175, 70, '开车')}
dic2 = {'李四': (170, 60, '旅游')}
dic3 = {'王五': (190, 80, '唱歌')}
f = open('user_info', 'a', encoding='utf-8')
st1 = json.dumps(dic1) # 先用json.dumps序列化成字符串
f.write(st1 + '\n') # 在write写入
st2 = json.dumps(dic2)
f.write(st2 + '\n')
st3 = json.dumps(dic3)
f.write(st3 + '\n')
f.close()
# 读取文件数据
f1 = open('user_info', 'r', encoding='utf-8')
for i in f1:
print(json.loads(i.strip())) # json.loads反序列化
f1.close()执行结果
{'张三': [175, 70, '开车']}
{'李四': [170, 60, '旅游']}
{'王五': [190, 80, '唱歌']}
总结：
dumps序列化 loads反序列化 只在内存中操作数据 主要用于网络传输 和多个数据与文件打交道
dump序列化 load反序列化 主要用于一个数据直接存在文件里--直接和文件打交道
json不支持元组，不支持除了str数据类型之外的key
json在写入多次dump的时候，不能对应执行多次load来取出数据，pickle可以
json如果要写入多个元素 可以先将元素dumps序列化， f.write(序列化+'\n')写入文件，读出元素的时候，应该先按行读文件，在使用loads将读出来的字符串转换成对应的数据类型
pickle模块
pickle，用于python特有的类型和python的数据类型间进行转换(只能用于python程序之间的交互)
pickle模块提供了四个功能:dumps,dump(序列化，存)，loads(反序列化,读)，load(不仅可以序列化字典，列表...可以把python中任意的数据类型序列化)
示例
import pickle
dic = {(1999, 20, '开车'): "张三"}
ret = pickle.dumps(dic) # 序列化结果 不是一个可读的字符串 而是一个bytes类型
print(ret)执行结果
b'\x80\x03}q\x00M\xcf\x07K\x14X\x06\x00\x00\x00\xe5\xbc\x80\xe8\xbd\xa6q\x01\x87q\x02X\x06\x00\x00\x00\xe5\xbc\xa0\xe4\xb8\x89q\x03s.'
利用pickle.loads反序列化读
import pickle
dic = {(1999, 20, '开车'): "张三"}
ret = pickle.dumps(dic) # 序列化结果 不是一个可读的字符串 而是一个bytes类型
print(pickle.loads(ret)) # 反序列化读执行结果
{(1999, 20, '开车'): '张三'}
文件操作模式必须带b，因为它是bytes类型,所以不需要指定编码
写入pickle.dump
import pickle
dic = {(1999, 20, '开车'): "张三"}
f = open('test', 'wb') # 因为是bytes类型，所以必须要带b，二进制
pickle.dump(dic, f)
f.close()执行结果,像乱码一样的东西
�}q M�KX 开车q�qX 张三qs.
读取pickle.load，因为它是bytes类型,所以不需要指定编码
import pickle
dic = {(1999, 20, '开车'): "张三"}
f = open('test', 'rb') # 因为是bytes类型，所以必须要带b，二进制
print(pickle.load(f))
f.close()执行结果
{(1999, 20, '开车'): '张三'}
pickle多行操作
import pickle
# 关于写多行
# 写入文件
dic1 = {(1999, 21, '开车'): "张三"}
dic2 = {(1998, 22, '唱歌'): "李四"}
dic3 = {(1997, 23, '跳舞'): "王五"}
f = open('test1', 'wb')
pickle.dump(dic1, f) # 序列化写入
pickle.dump(dic2, f) # 序列化写入
pickle.dump(dic3, f) # 序列化写入
f.close()
# 读取文件
f1 = open('test1', 'rb')
while True: # 循环读取
try:
print(pickle.load(f1))
except EOFError:
break执行结果
{(1999, 21, '开车'): '张三'}
{(1998, 22, '唱歌'): '李四'}
{(1997, 23, '跳舞'): '王五'}
关于序列化自定义类的对象
json错误示例
class A:
pass
a = A()
import json
json.dumps(a)执行报错
TypeError:
json只能是字符串
pickle示例
class A:
def __init__(self, name, age):
self.name = name
self.age = age
a = A('Sam', 80)
import pickle
ret = pickle.dumps(a) # 序列化一个对象
print(ret)
print(pickle.loads(ret)) # 读取对象(内存地址)
print(a.__dict__)执行结果
b'\x80\x03c__main__\nA\nq\x00)\x81q\x01}q\x02(X\x03\x00\x00\x00ageq\x03KPX\x04\x00\x00\x00nameq\x04X\x03\x00\x00\x00Samq\x05ub.'
{'name': 'Sam', 'age': 80}
将序列化对象写入文件
class A:
def __init__(self, name, age):
self.name = name
self.age = age
a = A('Sam', 80)
import pickle
ret = pickle.dumps(a) # 序列化一个对象
f = open('classes', 'wb')
pickle.dump(a, f) # 序列化对象a写入文件
f.close()
f1 = open('classes', 'rb')
obj = pickle.load(f1) # 反序列化读取对象赋值给obj
print(obj.__dict__)执行结果
{'age': 80, 'name': 'Sam'}
pickle错误示例
import pickle
f = open('classes', 'rb')
obj = pickle.load(f)
print(obj.__dict__)执行报错
AttributeError: Can't get attribute 'A'
将对象反序列化时，必须保证该对象在内存中存在，否则读取报错
既然pickle如此强大，为什么还要学json呢？
这里要说明一下,json是一种所有的语言都可以识别的数据结构,而pickle只能是针对python程序而言
shelve序列化,在python3.X之后才新增的
shelve也是python提供给我们的序列化工具，比pickle用起来更简单一些
shelve只提供给我们一个open方法，是用key来访问的，使用起来和字典类似
示例
import shelve
f = shelve.open('shelve_file')
# 直接对文件句柄操作，就可以存入数据
f['key'] = {'int':10, 'float':9.5, 'string':'hello world'}
f.close()执行结果，会产生3个文件
读取文件
import shelve
f = shelve.open('shelve_file')
# 直接对文件句柄操作，就可以存入数据
f['key'] = {'int':10, 'float':9.5, 'string':'hello world'}
f.close()
f1 = shelve.open('shelve_file')
s1 = f1['key']
print(s1)执行结果
{'int': 10, 'string': 'hello world', 'float': 9.5}
这个模块有个限制，它不支持多个应用同一时间往同一个DB进行写操作，所以当我们知道我们的应用如果只进行读操作，我们可以让shelve通过只读方式打开DB
import shelve
f = shelve.open('shelve_file', flag='r') # flag = 'r' 表示只读方式
s1 = f['key']
f.close()
print(s1)执行结果
{'int': 10, 'string': 'hello world', 'float': 9.5}
shelve中的一个bug
import shelve
f = shelve.open('shelve_file', flag='r') # flag = 'r' 表示只读方式
#f['key']['int'] = 50 # 不能修改已有结构中的值
#f['key']['new'] = 'new' # 不能在已有的结构中添加新的项
f['key'] = 'new' # 只读却覆盖了字典 不是很明显这里是什么意思！
print(f['key'])
f.close()执行结果
new
由于shelve在默认情况下是不会记录对持久化对象的任何修改的，所以我们在shelve.open()时候需要修改默认参数，否则对象的修改不会保存
新增一个属性
import shelve
f = shelve.open('shelve_file', writeback=True)
s1 = f['key']
f['key']['new_value'] = '人生苦短，我用Python'
print(s1)
f.close()执行结果
{'int': 10, 'new_value': '人生苦短，我用Python', 'string': 'hello world', 'float': 9.5}
shelve的writeback方式有优点也有缺点，优点是减少了我们出错的概率，并且让对象的持久化对用户更加的透明了；使用writeback以后，shelf在open()的时候会增加额外的内存消耗
序列化的使用：推荐使用json和picker
hashlib模块
算法介绍
Python的hashlib提供了常见的摘要算法，如md5,sha1等等。
什么是摘要算法呢？摘要算法又称哈希算法，散列算法。它通过一个函数，把任意长度的数据转换为一个长度固定的数据串(通常用16进制的字符串表示)
摘要算法就是通过摘要函数()对任意长度的数据data计算出固定长度的摘要digest,目的是为了发现原始数据是否被人篡改过。
用法：
1 文件的一致性校验
2 密文验证的时候加密
md5算法 通用的算法
sha算法 安全系数更高，sha算法有很多种，后面的数字越大安全系数越高，得到的数字结果越长，计算的时间越长
md5 加密示例
import hashlib
m = hashlib.md5()
m.update('Sam666'.encode('utf-8'))
print(m.hexdigest())
s = hashlib.md5()
s.update('Tom999'.encode('utf-8'))
print(s.hexdigest())执行结果
1f7062b5dc99693c421c273838c36f48
bb740188c8025148b53505e12f559ddf
这个是16进制的数，固定长度，结果是唯一的(hex)表示16进制
md5不能反解
暴力破解和撞库
将所有常见的密码(123456,admin,111111之类的) 都进行md5摘要，生成一个md5密码库，对比查询(暴力破解和撞库的实现)
怎么解决呢？
加盐
# 加盐md5 123456
m = hashlib.md5('admin'.encode('utf-8'))
m.update('123456'.encode('utf-8'))
print(m.hexdigest())
# 没加盐md5 123456
m = hashlib.md5()
m.update('123456'.encode('utf-8'))
print(m.hexdigest())执行结果
a66abb5684c45962d887564f08346e8d
e10adc3949ba59abbe56e057f20f883e
结果很明显不一样，如果加盐的密码不暴露，安全性要比单纯的md5高很多
更高级的方法(动态加盐)
import hashlib
username = input('输入账号:').strip()
password = input('输入密码:').strip()
m = hashlib.md5(username[::2].encode('utf-8')) #根据用户名(字符串切片动态加盐)
m.update(password.encode('utf-8'))
print(m.hexdigest())执行结果
输入账号:admin
输入密码:123456
a7aea2b468c1e775a411558475b661c7
因为每个用户名都是不同的，这种动态加盐的方式，会更安全，也不会被随便破解
文件的一致性校验
一段字符串直接进行摘要和分成几段摘要的结果是相同的
import hashlib
m = hashlib.md5()
m.update('hello,sam,I know your password is sam666'.encode('utf-8'))
print(m.hexdigest())
s = hashlib.md5()
s.update(b'hello,') # 前面加b是转成bytes类型
s.update(b'sam,')
s.update(b'I know your ')
s.update(b'password is sam666')
print(s.hexdigest())执行结果
d7a8902ae981eb2014d66a2e5f0a3574
d7a8902ae981eb2014d66a2e5f0a3574
文件内容的一致性校验
import hashlib
def check(filename):
m = hashlib.md5()
with open(filename, 'rb') as f:
content = f.read() # 直接读取所有内容
m.update(content) # 对内容进行摘要
return m.hexdigest()
ret1 = check('file1') # 执行前先创建两个文件，内容一样则md5码一样，有个标点不一样，md5则不同
ret2 = check('file2')
print(ret1)
print(ret2)执行结果
7c31d05a8123bea369e06d400aee8f2f
7c31d05a8123bea369e06d400aee8f2f
上面那种方法不可取，如果文件很大，全部读取的话，内存不够，系统会卡
第二种方法,因为字符串分段后，格式内容一致，那么md5码也是一样的，所以可以每次读取部分内容，这样操作，结果也不会影响
import hashlib
def check(filename):
m = hashlib.md5()
with open(filename, 'rb') as f:
while True:
content = f.read(4096) # 每次读取4096个字节
if content:
m.update(content) # 对内容进行摘要
else:
break
return m.hexdigest()
ret1 = check('file1')
ret2 = check('file2')
print(ret1)
print(ret2)执行结果
7c31d05a8123bea369e06d400aee8f2f
7c31d05a8123bea369e06d400aee8f2f
腾讯云开发者
