Python 序列化 pickle 模块
1. pickle 简介
2. pickle 核心函数
3. pickle 高级 —— 复杂对象
1. 序列化与 pickle 简介
1.1 什么是序列化？
所有的编程一定是围绕数据展开的，而数据呈现形式往往是结构化的，比如结构体（Struct）、类（Class）。 但是当我们通过网络、磁盘等传输、存储数据的时候却要求是二进制流。 比如 TCP 连接，它提供给上层应用的是面向连接的可靠字节流服务。那么如何将这些结构体和类转化为可存储和可传输的字节流呢？这就是序列化要干的事情，反之，从字节流如何恢复为结构化的数据就是反序列化。
序列化解决了对象持久化和跨网络数据交换的问题。要达到这个目的，有几种方法，每一种方法都有其优缺点。
例如，可以将对象数据存储在某种格式的文本文件中，譬如 CSV 文件。或者可以用关系数据库，譬如 Gadfly、MySQL、PostgreSQL 或者 DB2。这些文件格式和数据库都非常优秀，对于所有这些存储机制，Python 都有健壮的接口。
这些存储机制都有一个共同点：存储的数据是独立于对这些数据进行操作的对象和程序。这样做的好处是，数据可以作为共享的资源，供其它应用程序使用。缺点是，用这种方式，可以允许其它程序访问对象的数据，这违背了面向对象的封装性原则 — 即对象的数据只能通过这个对象自身的公共（public）接口来访问。
另外，对于某些应用程序，关系型数据库方法可能不是很理想。尤其是，关系型数据库不理解对象。相反，关系数据库会强行使用自己的类型系统和关系数据模型（表），每张表包含一组元组（行），每行包含具有固定数目的静态类型字段（列）。如果应用程序的对象模型不能够方便地转换到关系模型，那么在将对象映射到元组以及将元组映射回对象方面，会碰到一定难度。这种困难常被称为阻碍性不匹配（impedence-mismatch）问题。
1.2 对象序列化
在 Python 中，序列化过程称为 pickle，可以将对象 pickle 成字符串、磁盘上的文件或者任何类似于文件的对象，也可以将这些字符串、文件或任何类似于文件的对象 unpickle 成原来的对象。
假定您喜欢将任何事物都保存成对象，而且希望避免将对象转换成某种基于非对象存储的开销；那么 pickle 文件可以提供这些好处，但有时可能需要比这种简单的 pickle 文件更健壮以及更具有可伸缩性的事物。例如，只用 pickle 不能解决命名和查找 pickle 文件这样的问题，另外，它也不能支持并发地访问持久性对象。如果需要这些方面的功能，则要求助类似于 ZODB（针对 Python 的 Z 对象数据库）这类数据库。ZODB 是一个健壮的、多用户的和面向对象的数据库系统，它能够存储和管理任意复杂的 Python 对象，并支持事务操作和并发控制。令人足够感兴趣的是，甚至 ZODB 也依靠 Python 的本机序列化能力。而要想有效地使用 ZODB，首先必须充分了解 pickle。
1.3 pickle 模块简介
pickle 提供了一个简单的持久化功能。可以将对象以文件的形式存放在磁盘上。
Python 中几乎所有的数据类型（列表、字典、集合、类等）都可以用 pickle 来序列化。pickle 序列化后的数据，可读性差，人一般无法识别。
pickle 的可移植性
从空间和时间上说，Pickle 是可移植的。例如，可以在 Linux 下创建一个 pickle，然后将它发送到在 Windows 或 Mac OS 下运行的 Python 程序。并且，当升级到更新版本的 Python 时，不必担心可能要废弃已有的 pickle。Python 开发人员已经保证 pickle 格式将可以向后兼容 Python 各个版本。事实上，在 pickle 模块中提供了有关目前以及所支持的格式方面的详细信息。
2. pickle 函数
pickle 模块提供了以下函数：
- dumps(object)：将 python 对象转换（序列化）为字节（二进制）对象。
- loads(string)：将二进制对象转换（反序列为）为 python 对象。
- dump(object, file)：将对象写到文件，这个文件可以是实际的物理文件，也可以是任何类似于文件的对象，这个对象具有 write() 方法，可以接受单个的字符串参数。
- load(file)：返回包含在 pickle 文件中的对象。
缺省情况下， dumps() 和 dump() 使用可打印的 ASCII 表示来创建 pickle。两者都有一个 final 参数（可选，如果为 True，则该参数指定用更快以及更小的二进制表示来创建 pickle）。loads() 和 load() 函数则会自动检测 pickle 是二进制格式还是文本格式。事实上，在 pickle 模块中记录了所有使用的约定。
2.1 dumps() 和 loads()
- dumps(object)：将 python 对象转换（序列化）为字节（二进制）对象。
- loads(string)：将二进制对象转换（反序列为）为 python 对象。
示例：
# 将对象序列化为二进制 >>> o1 = ("this is string", 42, [1,2,3], {1:2}, None) >>> p1 = pickle.dumps(o1) >>> print(p1) b'\x80\x03(X\x0e\x00\x00\x00this is stringq\x00K*]q\x01(K\x01K\x02K\x03e}q\x02K\ x01K\x02sNtq\x03.' # 将二进制反序列化为对象 >>> o2 = pickle.loads(p1) >>> print(o2) ('this is string', 42, [1, 2, 3], {1: 2}, None)
在以上示例中，使用的都是简单对象，因此使用二进制 pickle 格式不会在节省空间上显示出太大的效率。然而，在实际使用复杂对象的系统中，使用二进制格式可以在大小和速度方面带来显著的改进。
2.2 dump() 和 load()
- dump(object, file)：将 python 对象写（序列化）到文件，这个文件可以是实际的物理文件，也可以是任何类似于文件的对象，这个对象具有 write() 方法，可以接受单个的字符串参数。
- load(file)：从文件中将二进制对象读取（反序列化）为 python 对象。
dump() 和 load() ，它们使用文件和类似文件的对象。这些函数的操作非常类似于我们刚才所看到的 dumps() 和 loads() ，区别在于它们还有另一种能力 — dump() 函数能一个接着一个地将几个对象转储到同一个文件。随后调用 load() 来以同样的顺序检索这些对象。
示例：
1 # 将对象序列化到二进制文件中 2 >>> a1 = "apple" 3 >>> b1 = {1:"one", 2:"two"} 4 >>> c1 = [1,"two"] 5 >>> f1 = open("tmp.pkl", "wb") 6 >>> pickle.dump(a1, f1) 7 >>> pickle.dump(b1, f1) 8 >>> pickle.dump(c1, f1) 9 >>> f1.close() 10 11 # 按序（先入先出）从二进制文件中反序列为对象 12 >>> f2 = open("tmp.pkl", "rb") 13 >>> a2 = pickle.load(f2) 14 >>> a2 15 'apple' 16 >>> b2 = pickle.load(f2) 17 >>> b2 18 {1: 'one', 2: 'two'} 19 >>> c2 = pickle.load(f2) 20 >>> c2 21 [1, 'two'] 22 >>> f2.close()
3. pickle 高级 —— 复杂对象
到目前为止，我们讲述了关于 pickle 方面的基本知识。在这一节，将讨论一些高级问题，当你开始 pickle 复杂对象时，会遇到这些问题，其中包括定制类的实例。幸运的是，Python 可以很容易地处理这种情形。
3.1 多个引用，同一对象
在 Python 中，变量是对象的引用。同时，也可以用多个变量引用同一个对象。经证明，Python 在用经过 pickle 的对象维护这种行为方面丝毫没有困难。
示例：对象引用的维护
1 >>> a = [1,2,3] 2 >>> b = a 3 >>> a 4 [1, 2, 3] 5 >>> b 6 [1, 2, 3] 7 >>> 8 >>> c = pickle.dumps((a,b)) 9 >>> d, e = pickle.loads(c) 10 >>> d 11 [1, 2, 3] 12 >>> e 13 [1, 2, 3] 14 >>> d.append(4) 15 >>> e 16 [1, 2, 3, 4]
3.2 循环引用和递归引用
可以将刚才演示过的对象引用支持扩展到 递归引用（一个对象包含对其自身的引用）和 循环引用（两个对象各自包含对对方的引用）。
示例：递归引用
1 >>> li = [1,2,3] 2 >>> li.append(li) 3 >>> li 4 [1, 2, 3, [...]] 5 >>> li[3] 6 [1, 2, 3, [...]] 7 >>> li[3][3] 8 [1, 2, 3, [...]] 9 >>> p = pickle.dumps(li) 10 >>> li2 = pickle.loads(p) 11 >>> li2 12 [1, 2, 3, [...]] 13 >>> li2[3] 14 [1, 2, 3, [...]] 15 >>> li2[3][3] 16 [1, 2, 3, [...]]
示例：循环引用
1 >>> a = [1,2] 2 >>> b = [3,4] 3 >>> a.append(b) 4 >>> b.append(a) 5 >>> a 6 [1, 2, [3, 4, [...]]] 7 >>> b 8 [3, 4, [1, 2, [...]]] 9 >>> a[2] 10 [3, 4, [1, 2, [...]]] 11 >>> a[2] is b 12 True 13 >>> f1 = open("tmp.pkl","wb") 14 >>> pickle.dump((a,b), f1) 15 >>> f1.close() 16 >>> 17 >>> f2 = open("tmp.pkl", "rb") 18 >>> c,d = pickle.load(f2) 19 >>> f2.close() 20 >>> c 21 [1, 2, [3, 4, [...]]] 22 >>> d 23 [3, 4, [1, 2, [...]]] 24 >>> c[2] is d 25 True
3.3 分别 pickle vs. 在一个元组中一起 pickle
如果分别 pickle 每个对象，而不是在一个元组中一起 pickle 所有对象，会得到略微不同（但很重要）的结果：在 pickle 情形中，每个对象被恢复到一个与原来对象相等的对象，但不是同一个对象。换句话说，每个 pickle 都是原来对象的一个副本。
1 # 通过元组一起pickle 2 >>> a = [1,2] 3 >>> b = a 4 >>> f1 = open("tmp.pkl", "wb") 5 >>> pickle.dump((a,b), f1) 6 >>> f1.close() 7 >>> 8 >>> f2 = open("tmp.pkl", "rb") 9 >>> c,d = pickle.load(f2) 10 >>> c is a 11 False 12 >>> c is d 13 True 14 >>> 15 16 # 分别pickle 17 >>> f3 = open("tmp.pkl", "wb") 18 >>> f3.close() 19 >>> a2 = [1,2] 20 >>> b2 = a2 21 >>> f3 = open("tmp.pkl", "wb") 22 >>> pickle.dump(a2, f3) 23 >>> pickle.dump(b2, f3) 24 >>> f3.close() 25 >>> 26 >>> f4 = open("tmp.pkl", "rb") 27 >>> c2 = pickle.load(f4) 28 >>> d2 = pickle.load(f4) 29 >>> f4.close() 30 >>> 31 >>> c2 32 [1, 2] 33 >>> d2 34 [1, 2] 35 >>> c2 is d2 36 False
3.4 维护分别 pickle 的对象间的引用
有一个选项确实允许分别 pickle 对象，并维护相互之间的引用，只要这些对象都是 pickle 到同一文件即可。 pickle 模块提供了一个 Pickler （与此相对应是 Unpickler ），它能够跟踪已经被 pickle 的对象。通过使用这个 Pickler ，将会通过引用而不是通过值来 pickle 共享和循环引用。
1 >>> f1 = open("tmp.pkl", "wb") 2 >>> pickler = pickle.Pickler(f1) 3 >>> a = [1,2] 4 >>> b = a 5 >>> pickler.dump(a) 6 >>> pickler.dump(b) 7 >>> f1.close() 8 >>> 9 >>> f2 = open("tmp.pkl", "rb") 10 >>> unpickler = pickle.Unpickler(f2) 11 >>> c = unpickler.load() 12 >>> d = unpickler.load() 13 >>> c 14 [1, 2] 15 >>> d 16 [1, 2] 17 >>> c is d # 注意与上一个示例的结果不同 18 True
3.5 不可 pickle 的对象
一些对象类型是不可 pickle 的。例如，Python 不能 pickle 文件对象（或者任何带有对文件对象引用的对象），因为 Python 在 unpickle 时不能保证它可以重建该文件的状态。试图 pickle 文件对象会导致以下错误：
1 >>> f = open("tmp.pkl", "wb") 2 >>> pickle.dumps(f) 3 Traceback (most recent call last): 4 File "<stdin>", line 1, in <module> 5 TypeError: cannot serialize '_io.BufferedWriter' object
3.6 类实例
与 pickle 简单对象类型相比，pickle 类实例要多加留意。这主要由于 Python 会 pickle 实例数据（通常是 _dict_ 属性）和类的名称，而不会 pickle 类的代码。当 Python unpickle 类的实例时，它会试图使用在 pickle 该实例时的确切的类名称和模块名称（包括任何包的路径前缀）导入包含该类定义的模块。另外要注意，类定义必须出现在模块的最顶层，这意味着它们不能是嵌套的类（在其它类或函数中定义的类）。
当 unpickle 类的实例时，通常不会再调用它们的 _init_() 方法。相反，Python 创建一个通用类实例，并应用已进行过 pickle 的实例属性，同时设置该实例的 _class_ 属性，使其指向原来的类。
对 Python 2.2 中引入的新型类进行 unpickle 的机制与原来的略有不同。虽然处理的结果实际上与对旧型类处理的结果相同，但 Python 使用 copy_reg 模块的 _reconstructor() 函数来恢复新型类的实例。
如果希望对新型或旧型类的实例修改缺省的 pickle 行为，则可以定义特殊的类的方法 _getstate_() 和 _setstate_() ，在保存和恢复类实例的状态信息期间，Python 会调用这些方法。
