python 序列化，反序列化

附：

pickle 有大量的配置选项和一些棘手的问题。对于最常见的使用场景，你不需要去担心这个,是如果你要在一个重要的程序中使用pickle 去做序列化的话，最好去查阅一下官方文档。

https://docs.python.org/3/library/pickle.html

----定义

通过将对象序列化可以将其存储在变量或者文件中，可以保存当时对象的状态，实现其生命周期的延长。并且需要时可以再次将这个对象读取出来。

----pickle模块

存变量里

--1--序列化对象，然后存储在变量中

>>> dic={'age':23,'job':'student'}
>>> byte_data=_pickle.dumps(dic)
>>> print(byte_data)
b'\x80\x03}q\x00(X\x03\x00\x00\x00jobq\x01X\x07\x00\x00\x00studentq\x02X\x03\x00\x00\x00ageq\x03K\x17u.'
>>>

--2--反序列化，把变量转换成对象

>>> obj=_pickle.loads(byte_data)
>>> print(obj)
{'job': 'student', 'age': 23}
>>>

存文件里

--1--序列化，把对象存储在文件中

Class Person:
    def __init__(self,name,age,job):
        self.name=name
        self.age=age
        self.job=job

    def work(self):
        print(self.name,'is working....')

>>> with open(r'c:\Temp\Person.pkl','wb') as f:
                pickle.dump(r'c:\Temp\Person.py',f)

>>>

--1--反序列化，把文件内容恢复成对象

with open('person.pkl', 'rb') as f:
    Person = pickle.load(f)
    aa = Person('gg', 23, '6')
    aa.work()
（type error:str object is not callable）老是这个错，不知道啥原因

 json模块

json是更标准的格式，有更好的可读性和跨平台性

--序列化成字符串

dic = {'age': 23, 'job': 'student'}
dic_str = json.dumps(dic)
print(type(dic_str), dic_str)
# out: <class 'str'> {"age": 23, "job": "student"}

dic_obj = json.loads(dic_str)
print(type(dic_obj), dic_obj)
# out: <class 'dict'> {'age': 23, 'job': 'student'}

dumps函数将对象转换成了字符串。loads函数又将其恢复成字典。

--存储为文件

class Person:
    def __init__(self, name, age, job):
        self.name = name
        self.age = age
        self.job = job

    def work(self):
        print(self.name, 'is working...')

aa = Person('Bob', 23, 'Student')
with open('abc.json', 'w', encoding='utf-8') as f:
    json.dump(aa, f) # 报错

Object of type 'Person' is not JSON serializable此时dump函数里传一个参default就可以了，这个参数接受一个函数，这个函数可以将对象转换为字典。

def person2dict(person):
    return {'name': person.name,
            'age': person.age,
            'job': person.job}

这样返回的就是一个字典了，对象实例有个方法可以简化这一过程。直接调用实例的__dict__。例如 print(aa.__dict) # {'name': 'Bob', 'age': 23, 'job': 'Student'}

同时在读取的时候load出来的是一个字典，再转回对象就可，同样需要一个object_hook参数，该参数接收一个函数，用于将字典转为对象。

def dict2person(dic):
    return Person(dic['name'], dic['age'], dic['job'])

with open('abc.json', 'w', encoding='utf-8') as f:
    json.dump(aa, f, default=person2dict)

with open('abc.json', encoding='utf-8') as f:
    obj = json.load(f, object_hook=dict2person)
    print(obj.name, obj.age, obj.job)
    obj.work()

由于可以使用__dict__代替person2dict函数，再使用lambda函数简化。

with open('abc.json', 'w', encoding='utf-8') as f:
   json.dump(aa, f, default=lambda obj: obj.__dict__)

shelve模块

通常使用一个open就好。shelve以键值对的形式存储数据

with shelve.open('aa', writeback=True) as f:
    dic = {'age': 23, 'job': 'student'}
    f['person'] = dic
    dic['age'] = 44
    f['person'] = dic

相当于赋值了两次，这种方法是可以改变值的。

默认情况下直接使用f['person']改变其中的值之后，不会更新已存储的值，也就是没有把更新写回到文件，即使是文件被close后。如果有此需要，在open函数中添加一个参数writeback=True。再次运行下看看年龄就被改变了。

写入自定义对象

依然使用上面的Person对象

with shelve.open('aa') as f:
    f['class'] = Person

# 写入类本身
with shelve.open('aa') as f:
    Person = f['class']
    a = Person('Bob', 23, 'Student')
    a.work()

上面的例子说明shelve也可以序列化类本身。当然序列化实例肯定可以。

with shelve.open('aa') as f:
    a = Person('God', 100, 'watch')
    f['class'] = a

with shelve.open('aa') as f:
    god = f['class']
    god.work()

参考

https://www.cnblogs.com/sun-haiyu/p/7087088.html