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

写一个类 定义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将读出来的字符串转换成对应的数据类型

 关于序列化自定义类的对象
class A:
    def __init__(self,name,age):
        self.name=name
        self.age=age
a = A('alex',80)
import json
json.dumps(a)   json无法序列化对象
import pickle
ret = pickle.dumps(a)
print(ret)
obj = pickle.loads(ret)
print(obj.__dict__)     pickle.loads(ret)反序列化回来的是对象的内存地址，所以用__dict__打开 

import pickle
f = open('大侄子1','wb')  创建文件句柄f，以'wb'形式写入
pickle.dump(a,f)   传入对象和文件句柄
f.close()         关闭文件
f = open('大侄子1','rb')     以'rb'形式打开文件句柄
obj = pickle.load(f)     传入文件句柄
print(obj.__dict__)      使用__dict__查看

shelve模块

import shelve # python 专有的序列化模块 只针对文件
f = shelve.open('dada')     # 打开文件
f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}  #直接对文件句柄操作，就可以存入数据
f.close()

import shelve
f1 = shelve.open('shelve_file')
existing = f1['key']  #取出数据的时候也只需要直接用key获取即可，但是如果key不存在会报错
f1.close()
print(existing)

设置只读方式
import shelve
f = shelve.open('shelve_file', flag='r')
existing = f['key']
f.close()
print(existing)

import shelve
f = shelve.open('shelve_file', flag='r')
f['key']['int'] = 50    # 不能修改已有结构中的值
f['key']['new'] = 'new' # 不能在已有的结构中添加新的项
f['key'] = 'new'         # 但是可以覆盖原来的结构
f.close()

hashlib  —— 摘要算法
    也是一些算法的集合，有好多算法
    字符串 --> 数字
    不同的字符串 -->  数字一定不同
    无论在哪台机器上，在什么时候计算，对相同的字符串结果总是一样的
    摘要过程不可逆

用法
文件的一致性校验
密文验证的时候加密

密文验证的时候加密

import hashlib
md5算法 通用的算法
sha算法 安全系数更高,sha算法有很多种，后面的数字越大安全系数越高，
        得到的数字结果越长，计算的时间越长
m = hashlib.md5()  #md5对象，md5不能反解，但是加密是固定的，就是关系是一一对应，所以有缺陷，可以被对撞出来
m.update('alex3714'.encode('utf-8')) #要对哪个字符串进行加密，就放这里必须是byte类型
print(m.hexdigest())  #拿到加密字符串

加盐
m = hashlib.md5('wahaha'.encode('utf-8'))
m.update('123456'.encode('utf-8'))
print(m.hexdigest())     

动态加盐
username = 'alex'  # 以用户名作为盐
m = hashlib.md5(username[::].encode('utf-8'))
m.update('123456'.encode('utf-8'))
print(m.hexdigest())

#hashlib简单使用
def md5(arg):#这是加密函数，将传进来的函数加密
    md5_pwd = hashlib.md5(bytes('abd',encoding='utf-8'))
    md5_pwd.update(bytes(arg,encoding='utf-8'))
    return md5_pwd.hexdigest()#返回加密的数据
def log(user,pwd):#登陆时候时候的函数，由于md5不能反解，因此登陆的时候用正解
    with open('db','r',encoding='utf-8') as f:
        for line in f:
            u,p=line.strip().split('|')
            if u ==user and p == md5(pwd):#登陆的时候验证用户名以及加密的密码跟之前保存的是否一样
                return True
def register(user,pwd):#注册的时候把用户名和加密的密码写进文件，保存起来
    with open('db','a',encoding='utf-8') as f:
        temp = user+'|'+md5(pwd)
        f.write(temp)

i=input('1表示登陆，2表示注册：')
if i=='':
    user = input('用户名：')
    pwd =input('密码：')
    register(user,pwd)
elif i=='':
    user = user = input('用户名：')
    pwd =input('密码：')
    r=log(user,pwd)#验证用户名和密码
    if r ==True:
        print('登陆成功')
    else:
        print('登陆失败')
else:
    print('账号不存在')