python开发_pickle

pickle模块使用的数据格式是python专用的，并且不同版本不向后兼容，同时也不能被其他语言说识别。要和其他语言交互，可以使用内置的json包使用pickle模块你可以把Python对象直接保存到文件，而不需要把他们转化为字符串，也不用底层的文件访问操作把它们写入到一个二进制文件里。 pickle模块会创建一个python语言专用的二进制格式，你基本上不用考虑任何文件细节，它会帮你干净利落地完成读写独享操作，唯一需要的只是一个合法的文件句柄。
        pickle模块中的两个主要函数是dump()和load()。dump()函数接受一个文件句柄和一个数据对象作为参数，把数据对象以特定的格式保存到给定的文件中。当我们使用load()函数从文件中取出已保存的对象时，pickle知道如何恢复这些对象到它们本来的格式。
        dumps()函数执行和dump() 函数相同的序列化。取代接受流对象并将序列化后的数据保存到磁盘文件，这个函数简单的返回序列化的数据。
        loads()函数执行和load() 函数一样的反序列化。取代接受一个流对象并去文件读取序列化后的数据，它接受包含序列化后的数据的str对象, 直接返回的对象。
        cPickle是pickle得一个更快得C语言编译版本。
        pickle和cPickle相当于java的序列化和反序列化操作

以上来源：http://www.2cto.com/kf/201009/74973.html

下面是python的API中的Example：

 # Simple example presenting how persistent ID can be used to pickle
 # external objects by reference.

 import pickle
 import sqlite3
 from collections import namedtuple

 # Simple class representing a record in our database.
 MemoRecord = namedtuple("MemoRecord", "key, task")

 class DBPickler(pickle.Pickler):

     def persistent_id(self, obj):
         # Instead of pickling MemoRecord as a regular class instance, we emit a
         # persistent ID.
         if isinstance(obj, MemoRecord):
             # Here, our persistent ID is simply a tuple, containing a tag and a
             # key, which refers to a specific record in the database.
             return ("MemoRecord", obj.key)
         else:
             # If obj does not have a persistent ID, return None. This means obj
             # needs to be pickled as usual.
             return None

 class DBUnpickler(pickle.Unpickler):

     def __init__(self, file, connection):
         super().__init__(file)
         self.connection = connection

     def persistent_load(self, pid):
         # This method is invoked whenever a persistent ID is encountered.
         # Here, pid is the tuple returned by DBPickler.
         cursor = self.connection.cursor()
         type_tag, key_id = pid
         if type_tag == "MemoRecord":
             # Fetch the referenced record from the database and return it.
             cursor.execute("SELECT * FROM memos WHERE key=?", (str(key_id),))
             key, task = cursor.fetchone()
             return MemoRecord(key, task)
         else:
             # Always raises an error if you cannot return the correct object.
             # Otherwise, the unpickler will think None is the object referenced
             # by the persistent ID.
             raise pickle.UnpicklingError("unsupported persistent object")

 def main():
     import io
     import pprint

     # Initialize and populate our database.
     conn = sqlite3.connect(":memory:")
     cursor = conn.cursor()
     cursor.execute("CREATE TABLE memos(key INTEGER PRIMARY KEY, task TEXT)")
     tasks = (
         'give food to fish',
         'prepare group meeting',
         'fight with a zebra',
         )
     for task in tasks:
         cursor.execute("INSERT INTO memos VALUES(NULL, ?)", (task,))

     # Fetch the records to be pickled.
     cursor.execute("SELECT * FROM memos")
     memos = [MemoRecord(key, task) for key, task in cursor]
     # Save the records using our custom DBPickler.
     file = io.BytesIO()
     DBPickler(file).dump(memos)

     print("Pickled records:")
     pprint.pprint(memos)

     # Update a record, just for good measure.
     cursor.execute("UPDATE memos SET task='learn italian' WHERE key=1")

     # Load the records from the pickle data stream.
     file.seek(0)
     memos = DBUnpickler(file, conn).load()

     print("Unpickled records:")
     pprint.pprint(memos)

 if __name__ == '__main__':
     main()

运行效果：