序列化和反序列化

序列化和反序列化

概念

序列化：按照某种规则，把内存中数据保存到文件中。

• 文件时一个字节序列，所以必须把数据转换成字节序列，输出到文件。

反序列化：从文件的字节序列恢复到内存并且还原原来的类型。

定义

• serialization 序列化，将内存中对象存储下来，把他变成一个个字节。->二进制
• deserialization 反序列化，将文件的一个个字节恢复成内存中对象。->二进制
  序列化保存到文件就是持久化，可以将数据序列化(持久化)后用于网络传输；也可以将从文件中或者网络接受到的字节序列反序列化
• Python中pickle库就是用来序列化和反序列化的。

Pickle库

•  dump(obj,file,protocol=None,*,fix_imports=True) #将obj对象序列化后写入file中

1. obj:需要序列化的对象
2. file：文件描述符，需要写入的文件描述符
3. protocol:协议
4. fix_imports:

• dumps(obj, protocol=None, *, fix_imports=True)->bytes #将obj对象序列化后返回序列化的bytes对象

1. obj:需要序列化的对象
2. protocol:协议
3. fix_imports:
4. bytes:返回值 序列化后的bytes

• load(file, *, fix_imports=True, encoding=“ASCII”, errors=“strict”) #从文件中读取内容反序列化。

1. file :文件描述符，序列化后生成的文件。
2. fix_imports:
3. encoding:文件编码，默认为ASCII
4. errors

• loads(bytes_object, *, fix_imports=True, encoding=“ASCII”, errors=“strict”)->从bytes中反序列化

1. bytes_object：序列化后的bytes对象
2. fix_imports:
3. encoding:编码
4. errors

示例

import pickle
i = 99
c = 'c'
l = list('123')
d = {"a":1,"b":"abc","c":[1,2,3]}

filename = "xddpython"
#序列化
with open(filename,'wb') as f:
    pickle.dump(i,f)
    pickle.dump(c,f)
    pickle.dump(l,f)
    pickle.dump(d,f)
#读取序列化后生成的文件
with open(filename,"rb") as f:
    print(f.read())
    
#反序列化
with open(filename,"rb") as f:
    while 1:
        try:
            x = pickle.load(f)
        except Exception:
            break;
        print(x)

类的序列化和反序列化

Python中的pickle模块，对类的序列化。记录了类名，方法名。以及类的属性。不会记录类中方法的执行代码。所以如果对同一个类序列化后。在改变类中的方法，然后将序列化的文件反序列化生成类，那么生成的类中会使用修改后的方法。

示例

import pickle
class AAA:
    ttt = "ABC"
    def show(self):
        print('abc')
#创建AAA对象
a1 = AAA()
print("序列化前：")
print("ttt = ",a1.ttt)
print("show()	",a1.show())
#序列化
ser = pickle.dumps(a1)
#重新定义类AAA
class AAA:
    ttt = "BBB"
    def show(self):
        print('def')
a2 = pickle.loads(ser)
print("反序列化后：")
print("ttt = ",a2.ttt)
print("show()	",a2.show())

总结

1. 注意对类的反序列化，运行环境中必须要有反序列化中记录的类的对象。如果没有无法反序列化，会出现AttributeError异常。
2. 对于类的序列化，序列化的bytes中会记录类名，以及方法名，和类的属性名和属性值。
3. 序列化和反序列化必须保证使用同一套类的定义，否则会带来不可预料的结果。