Python中的数据对象持久化存储模块pickle的使用示例
Python中可以使用pickle模块将对象转化为文件保存在磁盘上，在需要的时候再读取并还原。具体用法如下：
pickle是Python库中常用的序列化工具，可以将内存对象以文本或二进制格式导出为字符串，或者写入文档。后续可以从字符或文档中还原为内存对象。新版本的Python中用c重新实现了一遍，叫cPickle，性能更高。下面的代码演示了pickle库的常用接口用法，非常简单：
importcPickleaspickle
#dumpsandloads
#将内存对象dump为字符串，或者将字符串load为内存对象
deftest_dumps_and_loads():
t={'name':['v1','v2']}
printt
o=pickle.dumps(t)
printo
print'leno:',len(o)
p=pickle.loads(o)
printp
#关于HIGHEST_PROTOCOL参数，pickle支持3种protocol，0、1、2：
#http://stackoverflow.com/questions/23582489/python-pickle-protocol-choice
#0：ASCIIprotocol，兼容旧版本的Python
#1：binaryformat，兼容旧版本的Python
#2：binaryformat，Python2.3之后才有，更好的支持new-sytleclass
deftest_dumps_and_loads_HIGHEST_PROTOCOL():
print'HIGHEST_PROTOCOL:',pickle.HIGHEST_PROTOCOL
t={'name':['v1','v2']}
printt
o=pickle.dumps(t,pickle.HIGHEST_PROTOCOL)
print'leno:',len(o)
p=pickle.loads(o)
printp
#new-styleclass
deftest_new_sytle_class():
classTT(object):
def__init__(self,arg,**kwargs):
super(TT,self).__init__()
self.arg=arg
self.kwargs=kwargs
deftest(self):
printself.arg
printself.kwargs
#ASCIIprotocol
t=TT('test',a=1,b=2)
o1=pickle.dumps(t)
printo1
print'o1len:',len(o1)
p=pickle.loads(o1)
p.test()
#HIGHEST_PROTOCOL对new-styleclass支持更好，性能更高
o2=pickle.dumps(t,pickle.HIGHEST_PROTOCOL)
print'o2len:',len(o2)
p=pickle.loads(o2)
p.test()
#dumpandload
#将内存对象序列化后直接dump到文件或支持文件接口的对象中
#对于dump，需要支持write接口，接受一个字符串作为输入参数，比如：StringIO
#对于load，需要支持read接口，接受int输入参数，同时支持readline接口，无输入参数，比如StringIO
#使用文件，ASCII编码
deftest_dump_and_load_with_file():
t={'name':['v1','v2']}
#ASCIIformat
withopen('test.txt','w')asfp:
pickle.dump(t,fp)
withopen('test.txt','r')asfp:
p=pickle.load(fp)
printp
#使用文件，二进制编码
deftest_dump_and_load_with_file_HIGHEST_PROTOCOL():
t={'name':['v1','v2']}
withopen('test.bin','wb')asfp:
pickle.dump(t,fp,pickle.HIGHEST_PROTOCOL)
withopen('test.bin','rb')asfp:
p=pickle.load(fp)
printp
#使用StringIO，二进制编码
deftest_dump_and_load_with_StringIO():
importStringIO
t={'name':['v1','v2']}
fp=StringIO.StringIO()
pickle.dump(t,fp,pickle.HIGHEST_PROTOCOL)
fp.seek(0)
p=pickle.load(fp)
printp
fp.close()
#使用自定义类
#这里演示用户自定义类，只要实现了write、read、readline接口，
#就可以用作dump、load的file参数
deftest_dump_and_load_with_user_def_class():
importStringIO
classFF(object):
def__init__(self):
self.buf=StringIO.StringIO()
defwrite(self,s):
self.buf.write(s)
print'len:',len(s)
defread(self,n):
returnself.buf.read(n)
defreadline(self):
returnself.buf.readline()
defseek(self,pos,mod=0):
returnself.buf.seek(pos,mod)
defclose(self):
self.buf.close()
fp=FF()
t={'name':['v1','v2']}
pickle.dump(t,fp,pickle.HIGHEST_PROTOCOL)
fp.seek(0)
p=pickle.load(fp)
printp
fp.close()
#Pickler/Unpickler
#Pickler(file,protocol).dump(obj)等价于pickle.dump(obj,file[,protocol])
#Unpickler(file).load()等价于pickle.load(file)
#Pickler/Unpickler封装性更好，可以很方便的替换file
deftest_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()
printp
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-*-
importpickle
#也可以这样：
#importcPickleaspickle
obj={"a":1,"b":2,"c":3}
#将obj持久化保存到文件tmp.txt中
pickle.dump(obj,open("tmp.txt","w"))
#dosomethingelse...
#从tmp.txt中读取并恢复obj对象
obj2=pickle.load(open("tmp.txt","r"))
printobj2
#-*-coding:utf-8-*-
importpickle
#也可以这样：
#importcPickleaspickle
obj={"a":1,"b":2,"c":3}
#将obj持久化保存到文件tmp.txt中
pickle.dump(obj,open("tmp.txt","w"))
#dosomethingelse...
#从tmp.txt中读取并恢复obj对象
obj2=pickle.load(open("tmp.txt","r"))
printobj2
不过实际应用中，我们可能还会有一些改进，比如用cPickle来代替pickle，前者是后者的一个C语言实现版本，拥有更快的速度，另外，有时在dump时也会将第三个参数设为True以提高压缩比。再来看下面的例子：
#-*-coding:utf-8-*-
importcPickleaspickle
importrandom
importos
importtime
LENGTH=1024*10240
defmain():
d={}
a=[]
foriinrange(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-*-
importcPickleaspickle
importrandom
importos
importtime
LENGTH=1024*10240
defmain():
d={}
a=[]
foriinrange(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.297s dump2:4.750s 20992503,68894198,30.47% loading… load1:2.797s load2:10.125s
可以看到，dump时如果指定了protocol为True，压缩过后的文件的大小只有原来的文件的30%，同时无论在dump时还是load时所耗费的时间都比原来少。因此，一般来说，可以建议把这个值设为True。
另外，pickle模块还提供dumps和loads两个方法，用法与上面的dump和load方法类似，只是不需要输入file参数，输入及输出都是字符串对象，有些场景中使用这两个方法可能更为方便。