Python标准库 (pickle包，cPickle包)

     作者：Vamei 出处：http://www.cnblogs.com/vamei

     http://www.cnblogs.com/nju2014/p/5383992.html

  在之前对Python对象的介绍中 (面向对象的基本概念，面向对象的进一步拓展)，我提到过Python“一切皆对象”的哲学，在Python中，无论是变量还是函数，都是一个对象。当Python运行时，对象存储在内存中，随时等待系统的调用。然而，内存里的数据会随着计算机关机和消失，如何将对象保存到文件，并储存在硬盘上呢？

  计算机的内存中存储的是二进制的序列 (当然，在Linux眼中，是文本流)。我们可以直接将某个对象所对应位置的数据抓取下来，转换成文本流 (这个过程叫做serialize)，然后将文本流存入到文件中。由于Python在创建对象时，要参考对象的类定义，所以当我们从文本中读取对象时，必须在手边要有该对象的类定义，才能懂得如何去重建这一对象。从文件读取时，对于Python的内建(built-in)对象 (比如说整数、词典、表等等)，由于其类定义已经载入内存，所以不需要我们再在程序中定义类。但对于用户自行定义的对象，就必须要先定义类，然后才能从文件中载入对象 (比如面向对象的基本概念中的对象那个summer)。 

pickle包

对于上述过程，最常用的工具是Python中的pickle包。

1) 将内存中的对象转换成为文本流：

import pickle

# define class
class Bird(object):
    have_feather = True
    way_of_reproduction  = 'egg'

summer       = Bird()                 # construct an object
picklestring = pickle.dumps(summer)   # serialize object

使用pickle.dumps()方法可以将对象summer转换成了字符串 picklestring(也就是文本流)。随后我们可以用普通文本的存储方法来将该字符串储存在文件(文本文件的输入输出)。

当然，我们也可以使用pickle.dump()的方法，将上面两部合二为一:

import pickle

# define class
class Bird(object):
    have_feather = True
    way_of_reproduction  = 'egg'

summer       = Bird()                        # construct an object
fn           = 'a.pkl'
with open(fn, 'w') as f:                     # open file with write-mode
    picklestring = pickle.dump(summer, f)   # serialize and save object

对象summer存储在文件a.pkl

2) 重建对象

首先，我们要从文本中读出文本，存储到字符串 (文本文件的输入输出)。然后使用pickle.loads(str)的方法，将字符串转换成为对象。要记得，此时我们的程序中必须已经有了该对象的类定义。

此外，我们也可以使用pickle.load()的方法，将上面步骤合并:

import pickle

# define the class before unpickle
class Bird(object):
    have_feather = True
    way_of_reproduction  = 'egg'

fn     = 'a.pkl'
with open(fn, 'r') as f:
    summer = pickle.load(f)   # read file and build object

cPickle包

cPickle包的功能和用法与pickle包几乎完全相同 (其存在差别的地方实际上很少用到)，不同在于cPickle是基于c语言编写的，速度是pickle包的1000倍。对于上面的例子，如果想使用cPickle包，我们都可以将import语句改为:

import cPickle as pickle

就不需要再做任何改动了。

总结

对象 -> 文本 -> 文件

pickle.dump(), pickle.load(), cPickle

   Python序列化的概念很简单。内存里面有一个数据结构，你希望将它保存下来，重用，或者发送给其他人。你会怎么做？这取决于你想要怎么保存，怎么重用，发送给谁。很多游戏允许你在退出的时候保存进度，然后你再次启动的时候回到上次退出的地方。（实际上，很多非游戏程序也会这么干）在这种情况下，一个捕获了当前进度的数据结构需要在你退出的时候保存到硬盘上，接着在你重新启动的时候从硬盘上加载进来。
    Python标准库提供pickle和cPickle模块。cPickle是用C编码的，在运行效率上比pickle要高，但是cPickle模块中定义的类型不能被继承（其实大多数时候，我们不需要从这些类型中继承，推荐使用cPickle）。cPickle和pickle的序列化/反序列化规则是一样的，使用pickle序列化一个对象，可以使用cPickle来反序列化。同时，这两个模块在处理自引用类型时会变得更加“聪明”，它不会无限制的递归序列化自引用对象，对于同一对象的多次引用，它只会序列化一次。

   pickle模块中的两个主要函数是dump()和load()。dump()函数接受一个数据对象和一个文件句柄作为参数，把数据对象以特定的格式保存到给定的文件中。当我们使用load()函数从文件中取出已保存的对象时，pickle知道如何恢复这些对象到它们本来的格式。

dumps()函数执行和dump()函数相同的序列化。取代接受流对象并将序列化后的数据保存到磁盘文件，这个函数简单的返回序列化的数据。
loads()函数执行和load()函数一样的反序列化。取代接受一个流对象并去文件读取序列化后的数据，它接受包含序列化后的数据的str对象, 直接返回的对象。

pickle.dump(obj, file[, protocol])

这是将对象持久化的方法，参数的含义分别为：
obj: 要持久化保存的对象；
file: 一个拥有 write() 方法的对象，并且这个 write() 方法能接收一个字符串作为参数。这个对象可以是一个以写模式打开的文件对象或者一个 StringIO 对象，或者其他自定义的满足条件的对象。
protocol: 这是一个可选的参数，默认为 0 ，如果设置为 1 或 True，则以高压缩的二进制格式保存持久化后的对象，否则以ASCII格式保存。

对象被持久化后怎么还原呢？pickle 模块也提供了相应的方法，如下：

pickle.load(file)

 只有一个参数 file ，对应于上面 dump 方法中的 file 参数。这个 file 必须是一个拥有一个能接收一个整数为参数的 read() 方法以及一个不接收任何参数的 readline() 方法，并且这两个方法的返回值都应该是字符串。这可以是一个打开为读的文件对象、StringIO 对象或其他任何满足条件的对象。

下面是一个基本的用例：

# -*- coding: utf-8 -*-
 
import pickle
# 也可以这样：
# import cPickle as pickle
 
obj = {"a": 1, "b": 2, "c": 3}
 
# 将 obj 持久化保存到文件 tmp.txt 中
pickle.dump(obj, open("tmp.txt", "w"))
 
# do something else ...
 
# 从 tmp.txt 中读取并恢复 obj 对象
obj2 = pickle.load(open("tmp.txt", "r"))
 
print obj2

    不过实际应用中，我们可能还会有一些改进，比如用 cPickle 来代替 pickle ，前者是后者的一个 C 语言实现版本，拥有更快的速度，另外，有时在 dump 时也会将第三个参数设为 True 以提高压缩比。再来看下面的例子：

# -*- coding: utf-8 -*-
 
import cPickle as pickle
import random
import os
 
import time
 
LENGTH = 1024 * 10240
 
def main():
    d = {}
    a = []
    for i in range(LENGTH):
        a.append(random.randint(0, 255))
 
    d["a"] = a
 
    print "dumping..."
 
    t1 = time.time()
    pickle.dump(d, open("tmp1.dat", "wb"), True)
    print "dump1: %.3fs" % (time.time() - t1)
 
    t1 = time.time()
    pickle.dump(d, open("tmp2.dat", "w"))
    print "dump2: %.3fs" % (time.time() - t1)
 
    s1 = os.stat("tmp1.dat").st_size
    s2 = os.stat("tmp2.dat").st_size
 
    print "%d, %d, %.2f%%" % (s1, s2, 100.0 * s1 / s2)
 
    print "loading..."
 
    t1 = time.time()
    obj1 = pickle.load(open("tmp1.dat", "rb"))
    print "load1: %.3fs" % (time.time() - t1)
 
    t1 = time.time()
    obj2 = pickle.load(open("tmp2.dat", "r"))
    print "load2: %.3fs" % (time.time() - t1)
 
 
if __name__ == "__main__":
    main()

     可以看到，dump 时如果指定了 protocol 为 True，压缩过后的文件的大小只有原来的文件的 30% ，同时无论在 dump 时还是 load 时所耗费的时间都比原来少。因此，一般来说，可以建议把这个值设为 True 。

      另外，pickle 模块还提供 dumps 和 loads 两个方法，用法与上面的 dump 和 load 方法类似，只是不需要输入 file 参数，输入及输出都是字符串对象，有些场景中使用这两个方法可能更为方便。