python中可以使用 pickle 模块将对象转化为文件保存在磁盘上，在需要的时候再读取并还原。具体用法如下：
pickle是python库中常用的序列化工具，可以将内存对象以文本或二进制格式导出为字符串，或者写入文档。后续可以从字符或文档中还原为内存对象。新版本的python中用c重新实现了一遍，叫cpickle，性能更高。 下面的代码演示了pickle库的常用接口用法，非常简单：
import cpickle as pickle# dumps and loads# 将内存对象dump为字符串，或者将字符串load为内存对象def test_dumps_and_loads(): t = {'name': ['v1', 'v2']} print t o = pickle.dumps(t) print o print 'len o: ', len(o) p = pickle.loads(o) print p # 关于highest_protocol参数，pickle 支持3种protocol，0、1、2：# http://stackoverflow.com/questions/23582489/python-pickle-protocol-choice# 0：ascii protocol，兼容旧版本的python# 1：binary format，兼容旧版本的python# 2：binary format，python2.3 之后才有，更好的支持new-sytle classdef test_dumps_and_loads_highest_protocol(): print 'highest_protocol: ', pickle.highest_protocol t = {'name': ['v1', 'v2']} print t o = pickle.dumps(t, pickle.highest_protocol) print 'len o: ', len(o) p = pickle.loads(o) print p# new-style classdef test_new_sytle_class(): class tt(object): def __init__(self, arg, **kwargs): super(tt, self).__init__() self.arg = arg self.kwargs = kwargs def test(self): print self.arg print self.kwargs # ascii protocol t = tt('test', a=1, b=2) o1 = pickle.dumps(t) print o1 print 'o1 len: ', len(o1) p = pickle.loads(o1) p.test() # highest_protocol对new-style class支持更好，性能更高 o2 = pickle.dumps(t, pickle.highest_protocol) print 'o2 len: ', len(o2) p = pickle.loads(o2) p.test()# dump and load# 将内存对象序列化后直接dump到文件或支持文件接口的对象中# 对于dump，需要支持write接口，接受一个字符串作为输入参数，比如：stringio# 对于load，需要支持read接口，接受int输入参数，同时支持readline接口，无输入参数，比如stringio# 使用文件，ascii编码def test_dump_and_load_with_file(): t = {'name': ['v1', 'v2']} # ascii format with open('test.txt', 'w') as fp: pickle.dump(t, fp) with open('test.txt', 'r') as fp: p = pickle.load(fp) print p# 使用文件，二进制编码def test_dump_and_load_with_file_highest_protocol(): t = {'name': ['v1', 'v2']} with open('test.bin', 'wb') as fp: pickle.dump(t, fp, pickle.highest_protocol) with open('test.bin', 'rb') as fp: p = pickle.load(fp) print p# 使用stringio，二进制编码def test_dump_and_load_with_stringio(): import stringio t = {'name': ['v1', 'v2']} fp = stringio.stringio() pickle.dump(t, fp, pickle.highest_protocol) fp.seek(0) p = pickle.load(fp) print p fp.close()# 使用自定义类# 这里演示用户自定义类，只要实现了write、read、readline接口，# 就可以用作dump、load的file参数def test_dump_and_load_with_user_def_class(): import stringio class ff(object): def __init__(self): self.buf = stringio.stringio() def write(self, s): self.buf.write(s) print 'len: ', len(s) def read(self, n): return self.buf.read(n) def readline(self): return self.buf.readline() def seek(self, pos, mod=0): return self.buf.seek(pos, mod) def close(self): self.buf.close() fp = ff() t = {'name': ['v1', 'v2']} pickle.dump(t, fp, pickle.highest_protocol) fp.seek(0) p = pickle.load(fp) print p fp.close()# pickler/unpickler# pickler(file, protocol).dump(obj) 等价于 pickle.dump(obj, file[, protocol])# unpickler(file).load() 等价于 pickle.load(file)# pickler/unpickler 封装性更好，可以很方便的替换filedef test_pickler_unpickler(): t = {'name': ['v1', 'v2']} f = file('test.bin', 'wb') pick = pickle.pickler(f, pickle.highest_protocol) pick.dump(t) f.close() f = file('test.bin', 'rb') unpick = pickle.unpickler(f) p = unpick.load() print p f.close()
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 pickleobj = {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# -*- 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 pickleimport randomimport osimport timelength = 1024 * 10240def 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()# -*- coding: utf-8 -*- import cpickle as pickleimport randomimport 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()
在我的电脑上执行结果为：
dumping…dump1: 1.297sdump2: 4.750s20992503, 68894198, 30.47%loading…load1: 2.797sload2: 10.125s
可以看到，dump 时如果指定了 protocol 为 true，压缩过后的文件的大小只有原来的文件的 30% ，同时无论在 dump 时还是 load 时所耗费的时间都比原来少。因此，一般来说，可以建议把这个值设为 true 。
另外，pickle 模块还提供 dumps 和 loads 两个方法，用法与上面的 dump 和 load 方法类似，只是不需要输入 file 参数，输入及输出都是字符串对象，有些场景中使用这两个方法可能更为方便。