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

運行效果：