22.4-序列化和反序列化及pickle

一个人最重要的品质，是懂得克制，克制自己，不是冲动任性，克制自己的情绪。

而真正成熟的人，首先应该是一个懂得克制自己欲望的人！

总结：

1. pickle库是一个很重要的库，它的思想在后面很多库中都有体现的；是一个必须要学的库！
2. py2和py3 pickle协议可能是不同的；
3. 游戏保存：内存数据的保存（序列化与反序列化）， 游戏公司对Python需求比较大；
4. 所有语言编程都要考虑序列化与反序列化，使用pickle来认识一下，json只是在某些方向，不是所有地方都用，json效率低下;
5. 在序列化与反序列化中，类的属性方法是共有，不展示,在协议传输时必须一致； 实例 self是千变万化的、自己的，会展示出来；

内存中的字典、列表、集合以及各种对象，如何保存在一个文件中？

如何从文件中读取数据，并让它们在内存中再次恢复成自己对应的类的实例？
要设计一套协议，按照某种规则，把内存中数据保存到文件中。文件是一个字节序列，所以必须把数据转换成字节；

序列，输出到文件。这就是序列化。反之，从文件的字节序列恢复到内存，就是反序列化。

序列化

序列化：我们把变量从内存中变成可存储或传输的过程称之为序列化，在Python中叫pickling。序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。

反序列化：反过来，把变量内容从序列化的对象（字节序列）重新读到内存里称之为反序列化，即unpickling。

Python提供了pickle模块来实现序列化。

相关模块

本节要介绍的就是Python内置的几个用于进行数据序列化的模块：

模块名称	描述	提供的api
json	用于实现Python数据类型与通用（json）字符串之间的转换; 不是所有地方都用，json效率低下	dumps() 、dump() 、loads() 、 load()
pickle	用于实现Python数据类型与Python特定二进制格式之间的转换；不是一种很高效的协议序列化传输方案	dumps()、dump()、loads()、load()、
shelve	专门用于将Python数据类型的数据持久化到磁盘，shelve是一个类似dict的对象，操作十分便捷	open()

pickle模块

pickle模块实现了用于对Python对象结构进行 序列化 和 反序列化 的二进制协议，与json模块不同的是pickle模块序列化和反序列化的过程分别叫做pickling 和 unpickling：

pickling：是将Python对象转换为字节流的过程；
unpickling：是将字节流二进制文件或字节对象转换回Python对象的过程；

pickle模块提供的相关函数

pickle模块提供的几个序列化/反序列化的函数与json模块基本一致：

说明：上面这几个方法参数中，*号后面的参数都是Python 3.x新增的，目的是为了兼容Python 2.x，具体用法请参看官方文档。

# 将指定的Python对象通过pickle序列化作为bytes对象返回，而不是将其写入文件
dumps(obj, protocol=None, *, fix_imports=True)

# 将通过pickle序列化后得到的字节对象进行反序列化，转换为Python对象并返回
loads(bytes_object, *, fix_imports=True, encoding="ASCII", errors="strict")

# 将指定的Python对象通过pickle序列化后写入打开的文件对象中，等价于`Pickler(file, protocol).dump(obj)`
dump(obj, file, protocol=None, *, fix_imports=True)

# 从打开的文件对象中读取pickled对象表现形式并返回通过pickle反序列化后得到的Python对象
load(file, *, fix_imports=True, encoding="ASCII", errors="strict）

# 示例 dump 和 load 方法；
#内建方法；
i = int(99)
s = 'ABC'
l = {'a':0x111111,'b':'abcde','c':[123]}
import pickle

with open('./ser.txt','wb') as f:
    pickle.dump(i,f)  # 对象i ,文件f;
    pickle.dump(s,f)
    pickle.dump(l,f)
#---------------------------------------------------------------------------------------------------------
��Kc.��X�   ABCq .��}q (X�   aq�J��� X�   bq�X�   abcdeq�X�   cq�]q�K{au.

with open('./ser.txt','rb') as f:
    tmp = pickle.load(f)
    print(type(tmp),tmp)
    tmp = pickle.load(f)
    print(type(tmp),tmp)
    tmp = pickle.load(f)
    print(type(tmp),tmp)
#---------------------------------------------------------------------------------------------------------
<class 'int'> 99
<class 'str'> ABC
<class 'dict'> {'a': 1118481, 'b': 'abcde', 'c': [123]}


1.类的属性方法在序列化中不展示 ，在源代码中；
class AA:
    aaaa = 0x111111
    def show(self):
        print('abc')
        
x = AA()
print(x)

with open('./ser.txt','wb') as f:
    pickle.dump(x,f)  # 对象i ,文件f;
with open('./ser.txt','rb') as f:
    a = pickle.load(f)
    print(type(a),hex(a.aaaa))
    a.show()
#------------------------------------------------------------
<__main__.AA object at 0x000002704F7E8E48>
<class '__main__.AA'> 0x111111
abc

2. 序列化与反序列化 两边定义的类.方法要一致；

#序列化写入
class AA:
    aaaa = 0x111111
    def show(self):
        print('abc')
        
x = AA()

ser = pickle.dumps(x)
print(ser)

with open('./ser.txt','wb') as f:
    f.write(ser)
    
with open('./ser.txt','rb') as f:
    a = pickle.load(f)
    print(type(a),hex(a.aaaa))
    a.show()
#--------------------------------------------------
b'\x80\x03c__main__\nAA\nq\x00)\x81q\x01.'
<class '__main__.AA'> 0x111111
abc

# 反序列化解读
class AA:
    aaaa = 60000
    def show(self):
        print('xyz123')
        
with open('./ser.txt','rb') as f:
    a1 = pickle.load(f)
    print((a1.aaaa))
    a1.show()
#--------------------------------------------------
60000
xyz123


3. 类都是公有的，不展示；每一个self都是一个实例（千变万化）；都是自己的特征，会被序列化；
class AA:
    bbbb = 222   # 类都是公有的，不展示
    def __init__(self):
        self.aaaa = 0x111111   # 每一个self都是一个实例；都是自己的特征；
        
x = AA()

ser = pickle.dumps(x)
print(ser)

with open('./ser.txt','wb') as f:
    f.write(ser)
#----------------------------------------------------------------------------------------------
b'\x80\x03c__main__\nAA\nq\x00)\x81q\x01}q\x02X\x04\x00\x00\x00aaaaq\x03J\x11\x11\x11\x00sb.'

序列化应用——效率问题

一般来说，本地序列化的情况，应用较少。大多数场景都应用在网络传输中。

将数据序列化后通过网络传输到远程节点，远程服务器上的服务将接收到的数据反序列化后，就可以使用了。

但是，要注意一点，远程接收端，反序列化时必须有对应的数据类型，否则就会报错。尤其是自定义类，必须远程得有一致的定义。

现在，大多数项目，都不是单机的，也不是单服务的。需要通过网络将数据传送到其他节点上去，这就需要大量的序列化、反序列化过程。

但是，问题是，Python程序之间还可以都是用pickle解决序列化、反序列化，如果是跨平台、跨语言、跨协议pickle就不太适合了，就需要公共的协议。例如XML、Json、Protocol Buffer等，协议非常多。

不同的协议，效率不同、学习曲线不同，适用不同场景，要根据不同的情况分析选型。