Python中的数据对象持久化存储模块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 class
def 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 class
def 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 封装性更好，可以很方便的替换file
def 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 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
# -*- 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

# -*- 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()
# -*- 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()

dumping…
dump1: 1.297s
dump2: 4.750s
20992503, 68894198, 30.47%
loading…
load1: 2.797s
load2: 10.125s