Python中的数据对象持久化存储模块pickle的使用示例

概述Python中可以使用pickle模块将对象转化为文件保存在磁盘上，在需要的时候再读取并还原。具体用法如下：

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,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,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,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,"c": 3} # 将 obj 持久化保存到文件 tmp.txt 中pickle.dump(obj,"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,True) print "dump1: %.3fs" % (time.time() - t1)  t1 = time.time() pickle.dump(d,"w")) print "dump2: %.3fs" % (time.time() - t1)  s1 = os.stat("tmp1.dat").st_size s2 = os.stat("tmp2.dat").st_size  print "%d,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 参数，输入及输出都是字符串对象，有些场景中使用这两个方法可能更为方便。

总结

以上是内存溢出为你收集整理的Python中的数据对象持久化存储模块pickle的使用示例全部内容，希望文章能够帮你解决Python中的数据对象持久化存储模块pickle的使用示例所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。