0420模块 序列化模块 hashlib模块

Posted 2020-10-31 Murray穆

复习：内置方法

__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__  析构方法，在对象删除的时候，删除这个对象之前执行，主要用来关闭在对象中打开的系统的资源

写一个类 定义100个对象
拥有三个属性 name age sex
如果两个对象的name 和 sex完全相同
我们就认为这是一个对象
忽略age属性
做这100个对象的去重工作
*通过改写集合中的内置方法__hash__和__eg__，实现按要求去重
内置方法用好了还是非常牛逼的！
class Person:   定义类和属性，
    def __init__(self,name,age,sex):
        self.name = name
        self.age = age
        self.sex = sex
    def __hash__(self): 如果对象的name和sex相同，hash值肯定也相同 相加结果相同的对象，name和sex一定相同
        # hash算法本身就存在了 且直接在python中就能调用
　　　　# 姓名相同 性别相同的对象的hash值应该相等才行
　　　　# 姓名性别都是字符串

        return hash(self.name+self.sex) 
    def __eq__(self, other):比较完hash值，再比较两个对象的name和sex，如果相等，返回True，两重比较，双保险。
        if self.name == other.name and self.sex == other.sex:return True
p_lst = []
for i in range(84):
    p_lst.append(Person(‘egon‘,i,‘male‘)) 实例化对象，病放进一个列表
print(p_lst)   
print(set(p_lst))    利用重写内置方法的sex去重 set对一个对象序列的去重 依赖于这个对象的两个方法 hash eq

hash算法  一个值 进行一系列的计算得出一个数字在一次程序执行中总是不变来让每一个不同的值计算出的数字都不相等

set对一个对象序列的去重 如何判断这两个值是否相等
值a进行hash --> 存值
值b进行hash --> 判断值是否相等 -相等-> 说明是一样的
                                -不相等-> 在开辟一个空间 来存放b

模块

py文件就是模块
python之所以好用 模块多
  三种
    内置模块   python安装的时候自带的
    扩展模块   itchat                         # 别人写好的 需要安装之后可以直接使用
              beautiful soap
              selenium  网页自动化测试工具
              django tornado
    自定义模块 自己写的模块

序列化模块
能存储在文件中的一定是字符串 或者是 字节
能在网络上传输的 只有字节

python中的序列化模块
    json     所有的编程语言都通用的序列化格式
             它支持的数据类型非常有限 数字 字符串 列表 字典
    pickle   只能在python语言的程序之间传递数据用的
             pickle支持python中所有的数据类型
    shelve   python3.* 之后才有的

json模块
import json
dic = {‘张三‘:123}
print(type(json.dumps(dic,ensure_ascii=False)),json.dumps(dic,ensure_ascii=False))  #序列化
#<class ‘str‘> {"张三": 123}
dic1 = json.dumps(dic,ensure_ascii=False)
print(type(json.loads(dic1)),json.loads(dic1))  #反序列化
#<class ‘dict‘> {‘张三‘: 123

dump和load 是直接将对象序列化之后写入文件
f = open(‘dada‘,‘w‘,encoding=‘utf-8‘)
json.dump(dic,f,ensure_ascii=False)   # 先接收要序列化的对象 再接受文件句柄
f.close()
f = open(‘dada‘,‘r‘,encoding=‘utf-8‘)
ret =json.load(f)
print(ret,type(ret))  #{‘张三‘: 123} <class ‘dict‘>

data = {‘username‘:[‘李华‘,‘二愣子‘],‘sex‘:‘male‘,‘age‘:16}
json_dic2 = json.dumps(data,sort_keys=True,indent=4,separators=(‘,‘,‘:‘),ensure_ascii=False)
print(json_dic2)
结果：
{
    "age":16,
    "sex":"male",
    "username":[
        "李华",
        "二愣子"
    ]
}
各种参数：
sort_keys：按键的首字母排序  indent：缩进数量（红色下划线部分）   separators：分隔符

import json
dic = {‘张三‘:123}
dic1 = {‘赵四‘:123}
dic2= {‘广坤‘:123}
多个字典写入文件

f = open(‘dada‘,‘a‘,encoding=‘utf-8‘)
ret1 = json.dumps(dic,ensure_ascii=False)
f.write(ret1+‘\n‘)
ret2 = json.dumps(dic1,ensure_ascii=False)
f.write(ret2+‘\n‘)
ret3 = json.dumps(dic2,ensure_ascii=False)
f.write(ret3+‘\n‘)
f.close()
反序列化
f = open(‘dada‘,‘r‘)
for line in f:
    print(json.loads(line.strip()))
f.close()

dumps序列化 loads反序列化  只在内存中操作数据 主要用于网络传输 和多个数据与文件打交道
dump序列化  load反序列化   主要用于一个数据直接存在文件里—— 直接和文件打交道

import json
dic = {(190,90,‘捏脚‘):"大表哥"}    # json不支持元组 不支持除了str数据类型之外的key
print(json.dumps(dic))

 

pickle

import pickle
dic = {(190,90,‘捏脚‘):"大表哥"}
print(pickle.dumps(dic))   #一串二进制内容  序列化结果 不是一个可读的字符串 而是一个bytes类型
#b‘\x80\x03}q\x00K\xbeKZX\x06\x00\x00\x00\xe6\x8d\x8f\xe8\x84\x9aq\x01\x87q\x02X\t\x00\x00\x00\xe5\xa4\xa7\xe8\xa1\xa8\xe5\x93\xa5q\x03s.‘
ret = pickle.dumps(dic)
print(pickle.loads(ret)) # {(190, 90, ‘捏脚‘): ‘大表哥‘}

写入文件
f = open(‘dada‘,‘wb‘)    # 使用pickle dump必须以+b的形式打开文件
pickle.dump(dic,f)
f.close()
从文件中取出
f=open(‘dada‘,‘rb‘)
print(pickle.load(f))
f.close()

import pickle
关于写多行
dic1 = {"大表哥":(190,90,‘捏脚‘)}
dic2 = {"2表哥":(190,90,‘捏脚‘)}
dic3 = {"3表哥":(190,90,‘捏脚‘)}
f = open(‘大表哥3‘,‘wb‘)
pickle.dump(dic1,f)
pickle.dump(dic2,f)
pickle.dump(dic3,f)
f.close() 

读取多行
f = open(‘dada‘,‘rb‘)
while True:
    try:
        print(pickle.load(f))
    except EOFError:
        break

json 在写入多次dump的时候 不能对应执行多次load来取出数据，pickle可以
json 如果要写入多个元素 可以先将元素dumps序列化，f.write(序列化+‘\n‘)写入文件
           读出元素的时候，应该先按行读文件，在使用loads将读出来的字符串转换成对应的数据类型