写一个类 定义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

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))

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