一个人最重要的品质，是懂得克制，克制自己，不是冲动任性，克制自己的情绪。
而真正成熟的人，首先应该是一个懂得克制自己欲望的人！
总结：
- pickle库是一个很重要的库，它的思想在后面很多库中都有体现的；是一个必须要学的库！
- py2和py3 pickle协议可能是不同的；
- 游戏保存：内存数据的保存（序列化与反序列化）， 游戏公司对Python需求比较大；
- 所有语言编程都要考虑序列化与反序列化，使用pickle来认识一下，json只是在某些方向，不是所有地方都用，json效率低下;
- 在序列化与反序列化中，类的属性方法是共有，不展示,在协议传输时必须一致； 实例 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)
#---------------------------------------------------------------------------------------------------------
99
ABC
{'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>
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.'
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等，协议非常多。
不同的协议，效率不同、学习曲线不同，适用不同场景，要根据不同的情况分析选型。