LINUX應用技巧，序列化存儲Python對象

　　什麼是持久性？
　　持久性的基本思想很簡單。假定有一個 Python 程序，它可能是一個管理日常待辦事項的程序，您希望在多次執行這個程序之間可以保存應用程序對象（待辦事項）。換句話說，您希望將對象存儲在磁碟上，便於以後檢索。這就是持久性。要達到這個目的，有幾種方法，每一種方法都有其優缺點。
　　
　　例如，可以將對象數據存儲在某種格式的文本文件中，譬如 CSV 文件。或者可以用關係資料庫，譬如 Gadfly、MySQL、PostgreSQL 或者 DB2。這些文件格式和資料庫都非常優秀，對於所有這些存儲機制，Python 都有健壯的介面。
　　
　　這些存儲機制都有一個共同點：存儲的數據是獨立於對這些數據進行操作的對象和程序。這樣做的好處是，數據可以作為共享的資源，供其它應用程序使用。缺點是，用這種方式，可以允許其它程序訪問對象的數據，這違背了面向對象的封裝性原則 — 即對象的數據只能通過這個對象自身的公共（public）介面來訪問。
　　
　　另外，對於某些應用程序，關係資料庫方法可能不是很理想。尤其是，關係資料庫不理解對象。相反，關係資料庫會強行使用自己的類型系統和關係數據模型（表），每張表包含一組元組（行），每行包含具有固定數目的靜態類型欄位（列）。如果應用程序的對象模型不能夠方便地轉換到關係模型，那麼在將對象映射到元組以及將元組映射回對象方面，會碰到一定難度。這種困難常被稱為阻礙性不匹配（impedence-mismatch）問題。
　　
　　對象持久性
　　如果希望透明地存儲 Python 對象，而不丟失其身份和類型等信息，則需要某種形式的對象序列化：它是一個將任意複雜的對象轉成對象的文本或二進位表示的過程。同樣，必須能夠將對象經過序列化后的形式恢復到原有的對象。在 Python 中，這種序列化過程稱為 pickle，可以將對象 pickle 成字元串、磁碟上的文件或者任何類似於文件的對象，也可以將這些字元串、文件或任何類似於文件的對象 unpickle 成原來的對象。我們將在本文後面詳細討論 pickle。
　　
　　假定您喜歡將任何事物都保存成對象，而且希望避免將對象轉換成某種基於非對象存儲的開銷；那麼 pickle 文件可以提供這些好處，但有時可能需要比這種簡單的 pickle 文件更健壯以及更具有可伸縮性的事物。例如，只用 pickle 不能解決命名和查找 pickle 文件這樣的問題，另外，它也不能支持併發地訪問持久性對象。如果需要這些方面的功能，則要求助類似於 ZODB（針對 Python 的 Z 對象資料庫）這類資料庫。ZODB 是一個健壯的、多用戶的和面向對象的資料庫系統，它能夠存儲和管理任意複雜的 Python 對象，並支持事務操作和併發控制。（請參閱參考資料，以下載 ZODB。）令人足夠感興趣的是，甚至 ZODB 也依靠 Python 的本機序列化能力，而且要有效地使用 ZODB，必須充分了解 pickle。
　　
　　另一種令人感興趣的解決持久性問題的方法是 Prevayler，它最初是用 Java 實現的（有關 Prevaylor 方面的 developerWorks 文章，請參閱參考資料）。最近，一群 Python 程序員將 Prevayler 移植到了 Python 上，另起名為 PyPerSyst，由 SourceForge 託管（有關至 PyPerSyst 項目的鏈接，請參閱參考資料）。Prevayler/PyPerSyst 概念也是建立在 Java 和 Python 語言的本機序列化能力之上。PyPerSyst 將整個對象系統保存在內存中，並通過不時地將系統快照 pickle 到磁碟以及維護一個命令日誌（通過此日誌可以重新應用最新的快照）來提供災難恢復。所以，儘管使用 PyPerSyst 的應用程序受到可用內存的限制，但好處是本機對象系統可以完全裝入到內存中，因而速度極快，而且實現起來要比如 ZODB 這樣的資料庫簡單，ZODB 允許對象的數目比同時在能內存中所保持的對象要多。
　　
　　既然我們已經簡要討論了存儲持久對象的各種方法，那麼現在該詳細探討 pickle 過程了。雖然我們主要感興趣的是探索以各種方式來保存 Python 對象，而不必將其轉換成某種其它格式，但我們仍然還有一些需要關注的地方，譬如：如何有效地 pickle 和 unpickle 簡單對象以及複雜對象，包括定製類的實例；如何維護對象的引用，包括循環引用和遞歸引用；以及如何處理類定義發生的變化，從而使用以前經過 pickle 的實例時不會發生問題。我們將在隨後關於 Python 的 pickle 能力探討中涉及所有這些問題。
　　
　　一些經過 pickle 的 Python
　　pickle 模塊及其同類模塊 cPickle 向 Python 提供了 pickle 支持。後者是用 C 編碼的，它具有更好的性能，對於大多數應用程序，推薦使用該模塊。我們將繼續討論 pickle，但本文的示例實際是利用了 cPickle。由於其中大多數示例要用 Python shell 來顯示，所以先展示一下如何導入 cPickle，並可以作為 pickle 來引用它：
　　
　　>>> import cPickle as pickle
　　現在已經導入了該模塊，接下來讓我們看一下 pickle 介面。pickle 模塊提供了以下函數對：dumps(object) 返回一個字元串，它包含一個 pickle 格式的對象；loads(string) 返回包含在 pickle 字元串中的對象；dump(object, file) 將對象寫到文件，這個文件可以是實際的物理文件，但也可以是任何類似於文件的對象，這個對象具有 write() 方法，可以接受單個的字元串參數；load(file) 返回包含在 pickle 文件中的對象。
　　
　　預設情況下，dumps() 和 dump() 使用可列印的 ASCII 表示來創建 pickle。兩者都有一個 final 參數（可選），如果為 True，則該參數指定用更快以及更小的二進位表示來創建 pickle。loads() 和 load() 函數自動檢測 pickle 是二進位格式還是文本格式。
　　
　　清單 1 顯示了一個互動式會話，這裡使用了剛才所描述的 dumps() 和 loads() 函數：
　　
　　清單 1. dumps() 和 loads() 的演示
　　Welcome To PyCrust 0.7.2 - The Flakiest Python Shell
　　Sponsored by Orbtech - Your source for Python programming expertise.
　　Python 2.2.1 (#1, Aug 27 2002, 10:22:32)
　　[GCC 3.2 (Mandrake Linux 9.0 3.2-1mdk)] on linux-i386
　　Type "copyright", "credits" or "license" for more information.
　　>>> import cPickle as pickle
　　>>> t1 = ('this is a string', 42, [1, 2, 3], None)
　　>>> t1
　　('this is a string', 42, [1, 2, 3], None)
　　>>> p1 = pickle.dumps(t1)
　　>>> p1
　　"(S'this is a string'\nI42\n(lp1\nI1\naI2\naI3\naNtp2\n."
　　>>> print p1
　　(S'this is a string'
　　I42
　　(lp1
　　I1
　　aI2
　　aI3
　　aNtp2
　　.
　　>>> t2 = pickle.loads(p1)
　　>>> t2
　　('this is a string', 42, [1, 2, 3], None)
　　>>> p2 = pickle.dumps(t1, True)
　　>>> p2
　　'(U\x10this is a stringK*]q\x01(K\x01K\x02K\x03eNtq\x02.'
　　>>> t3 = pickle.loads(p2)
　　>>> t3
　　('this is a string', 42, [1, 2, 3], None)
　　
　　註：該文本 pickle 格式很簡單，這裡就不解釋了。事實上，在 pickle 模塊中記錄了所有使用的約定。我們還應該指出，在我們的示例中使用的都是簡單對象，因此使用二進位 pickle 格式不會在節省空間上顯示出太大的效率。然而，在實際使用複雜對象的系統中，您會看到，使用二進位格式可以在大小和速度方面帶來顯著的改進。
　　
　　接下來，我們看一些示例，這些示例用到了 dump() 和 load()，它們使用文件和類似文件的對象。這些函數的操作非常類似於我們剛才所看到的 dumps() 和 loads()，區別在於它們還有另一種能力 — dump() 函數能一個接著一個地將幾個對象轉儲到同一個文件。隨後調用 load() 來以同樣的順序檢索這些對象。清單 2 顯示了這種能力的實際應用：
　　
　　清單 2. dump() 和 load() 示例
　　>>> a1 = 'apple'
　　>>> b1 = {1: 'One', 2: 'Two', 3: 'Three'}
　　>>> c1 = ['fee', 'fie', 'foe', 'fum']
　　>>> f1 = file('temp.pkl', 'wb')
　　>>> pickle.dump(a1, f1, True)
　　>>> pickle.dump(b1, f1, True)
　　>>> pickle.dump(c1, f1, True)
　　>>> f1.close()
　　>>> f2 = file('temp.pkl', 'rb')
　　>>> a2 = pickle.load(f2)
　　>>> a2
　　'apple'
　　>>> b2 = pickle.load(f2)
　　>>> b2
　　{1: 'One', 2: 'Two', 3: 'Three'}
　　>>> c2 = pickle.load(f2)
　　>>> c2
　　['fee', 'fie', 'foe', 'fum']
　　>>> f2.close()
　　
　　Pickle 的威力
　　到目前為止，我們講述了關於 pickle 方面的基本知識。在這一節，將討論一些高級問題，當您開始 pickle 複雜對象時，會遇到這些問題，其中包括定製類的實例。幸運的是，Python 可以很容易地處理這種情形。
　　
　　可移植性
　　從空間和時間上說，Pickle 是可移植的。換句話說，pickle 文件格式獨立於機器的體系結構，這意味著，例如，可以在 Linux 下創建一個 pickle，然後將它發送到在 Windows 或 Mac OS 下運行的 Python 程序。並且，當升級到更新版本的 Python 時，不必擔心可能要廢棄已有的 pickle。Python 開發人員已經保證 pickle 格式將可以向後兼容 Python 各個版本。事實上，在 pickle 模塊中提供了有關目前以及所支持的格式方面的詳細信息：
　　
　　清單 3. 檢索所支持的格式
　　>>> pickle.format_version
　　'1.3'
　　>>> pickle.compatible_formats
　　['1.0', '1.1', '1.2']
　　
　　多個引用，同一對象
　　在 Python 中，變數是對象的引用。同時，也可以用多個變數引用同一個對象。經證明，Python 在用經過 pickle 的對象維護這種行為方面絲毫沒有困難，如清單 4 所示：
　　
　　清單 4. 對象引用的維護
　　>>> a = [1, 2, 3]
　　>>> b = a
　　>>> a
　　[1, 2, 3]
　　>>> b
　　[1, 2, 3]
　　>>> a.append(4)
　　>>> a
　　[1, 2, 3, 4]
　　>>> b
　　[1, 2, 3, 4]
　　>>> c = pickle.dumps((a, b))
　　>>> d, e = pickle.loads(c)
　　>>> d
　　[1, 2, 3, 4]
　　>>> e
　　[1, 2, 3, 4]
　　>>> d.append(5)
　　>>> d
　　[1, 2, 3, 4, 5]
　　>>> e
　　[1, 2, 3, 4, 5]
　　
　　循環引用和遞歸引用
　　可以將剛才演示過的對象引用支持擴展到循環引用（兩個對象各自包含對對方的引用）和遞歸引用（一個對象包含對其自身的引用）。下面兩個清單著重顯示這種能力。我們先看一下遞歸引用：
　　
　　清單 5. 遞歸引用
　　>>> l = [1, 2, 3]
　　>>> l.append(l)
　　>>> l
　　[1, 2, 3, [...]]
　　>>> l[3]
　　[1, 2, 3, [...]]
　　>>> l[3][3]
　　[1, 2, 3, [...]]
　　>>> p = pickle.dumps(l)
　　>>> l2 = pickle.loads(p)
　　>>> l2
　　[1, 2, 3, [...]]
　　>>> l2[3]
　　[1, 2, 3, [...]]
　　>>> l2[3][3]
　　[1, 2, 3, [...]]
　　
　　現在，看一個循環引用的示例：
　　
　　清單 6. 循環引用
　　>>> a = [1, 2]
　　>>> b = [3, 4]
　　>>> a.append(b)
　　>>> a
　　[1, 2, [3, 4]]
　　>>> b.append(a)
　　>>> a
　　[1, 2, [3, 4, [...]]]
　　>>> b
　　[3, 4, [1, 2, [...]]]
　　>>> a[2]
　　[3, 4, [1, 2, [...]]]
　　>>> b[2]
　　[1, 2, [3, 4, [...]]]
　　>>> a[2] is b
　　1
　　>>> b[2] is a
　　1
　　>>> f = file('temp.pkl', 'w')
　　>>> pickle.dump((a, b), f)
　　>>> f.close()
　　>>> f = file('temp.pkl', 'r')
　　>>> c, d = pickle.load(f)
　　>>> f.close()
　　>>> c
　　[1, 2, [3, 4, [...]]]
　　>>> d
　　[3, 4, [1, 2, [...]]]
　　>>> c[2]
　　[3, 4, [1, 2, [...]]]
　　>>> d[2]
　　[1, 2, [3, 4, [...]]]
　　>>> c[2] is d
　　1
　　>>> d[2] is c
　　1
　　
　　注意，如果分別 pickle 每個對象，而不是在一個元組中一起 pickle 所有對象，會得到略微不同（但很重要）的結果，如清單 7 所示：
　　
　　清單 7. 分別 pickle vs. 在一個元組中一起 pickle
　　>>> f = file('temp.pkl', 'w')
　　>>> pickle.dump(a, f)
　　>>> pickle.dump(b, f)
　　>>> f.close()
　　>>> f = file('temp.pkl', 'r')
　　>>> c = pickle.load(f)
　　>>> d = pickle.load(f)
　　>>> f.close()
　　>>> c
　　[1, 2, [3, 4, [...]]]
　　>>> d
　　[3, 4, [1, 2, [...]]]
　　>>> c[2]
　　[3, 4, [1, 2, [...]]]
　　>>> d[2]
　　[1, 2, [3, 4, [...]]]
　　>>> c[2] is d
　　0
　　>>> d[2] is c
　　0
　　
　　相等，但並不總是相同
　　正如在上一個示例所暗示的，只有在這些對象引用內存中同一個對象時，它們才是相同的。在 pickle 情形中，每個對象被恢復到一個與原來對象相等的對象，但不是同一個對象。換句話說，每個 pickle 都是原來對象的一個副本：
　　
　　清單 8. 作為原來對象副本的被恢復的對象
　　>>> j = [1, 2, 3]
　　>>> k = j
　　>>> k is j
　　1
　　>>> x = pickle.dumps(k)
　　>>> y = pickle.loads(x)
　　>>> y
　　[1, 2, 3]
　　>>> y == k
　　1
　　>>> y is k
　　0
　　>>> y is j
　　0
　　>>> k is j
　　1
　　
　　同時，我們看到 Python 能夠維護對象之間的引用，這些對象是作為一個單元進行 pickle 的。然而，我們還看到分別調用 dump() 會使 Python 無法維護對在該單元外部進行 pickle 的對象的引用。相反，Python 複製了被引用對象，並將副本和被 pickle 的對象存儲在一起。對於 pickle 和恢復單個對象層次結構的應用程序，這是沒有問題的。但要意識到還有其它情形。
　　
　　值得指出的是，有一個選項確實允許分別 pickle 對象，並維護相互之間的引用，只要這些對象都是 pickle 到同一文件即可。pickle 和 cPickle 模塊提供了一個 Pickler（與此相對應是 Unpickler），它能夠跟蹤已經被 pickle 的對象。通過使用這個 Pickler，將會通過引用而不是通過值來 pickle 共享和循環引用：
　　
　　清單 9. 維護分別 pickle 的對象間的引用
　　>>> f = file('temp.pkl', 'w')
　　>>> pickler = pickle.Pickler(f)
　　>>> pickler.dump(a)
　　
　　>>> pickler.dump(b)
　　
　　>>> f.close()
　　>>> f = file('temp.pkl', 'r')
　　>>> unpickler = pickle.Unpickler(f)
　　>>> c = unpickler.load()
　　>>> d = unpickler.load()
　　>>> c[2]
　　[3, 4, [1, 2, [...]]]
　　>>> d[2]
　　[1, 2, [3, 4, [...]]]
　　>>> c[2] is d
　　1
　　>>> d[2] is c
　　1
　　
　　不可 pickle 的對象
　　一些對象類型是不可 pickle 的。例如，Python 不能 pickle 文件對象（或者任何帶有對文件對象引用的對象），因為 Python 在 unpickle 時不能保證它可以重建該文件的狀態（另一個示例比較難懂，在這類文章中不值得提出來）。試圖 pickle 文件對象會導致以下錯誤：
　　
　　清單 10. 試圖 pickle 文件對象的結果
　　>>> f = file('temp.pkl', 'w')
　　>>> p = pickle.dumps(f)
　　Traceback (most recent call last):
　　File "", line 1, in ?
　　File "/usr/lib/python2.2/copy_reg.py", line 57, in _reduce
　　raise TypeError, "can't pickle %s objects" % base.__name__
　　TypeError: can't pickle file objects
　　
　　類實例
　　與 pickle 簡單對象類型相比，pickle 類實例要多加留意。這主要由於 Python 會 pickle 實例數據（通常是 _dict_ 屬性）和類的名稱，而不會 pickle 類的代碼。當 Python unpickle 類的實例時，它會試圖使用在 pickle 該實例時的確切的類名稱和模塊名稱（包括任何包的路徑前綴）導入包含該類定義的模塊。另外要注意，類定義必須出現在模塊的最頂層，這意味著它們不能是嵌套的類（在其它類或函數中定義的類）。
　　
　　當 unpickle 類的實例時，通常不會再調用它們的 _init_() 方法。相反，Python 創建一個通用類實例，並應用已進行過 pickle 的實例屬性，同時設置該實例的 _class_ 屬性，使其指向原來的類。
　　
　　對 Python 2.2 中引入的新型類進行 unpickle 的機制與原來的略有不同。雖然處理的結果實際上與對舊型類處理的結果相同，但 Python 使用 copy_reg 模塊的 _reconstructor() 函數來恢復新型類的實例。
　　
　　如果希望對新型或舊型類的實例修改預設的 pickle 行為，則可以定義特殊的類的方法 _getstate_() 和 _setstate_()，在保存和恢復類實例的狀態信息期間，Python 會調用這些方法。在以下幾節中，我們會看到一些示例利用了這些特殊的方法。
　　
　　現在，我們看一個簡單的類實例。首先，創建一個 persist.py 的 Python 模塊，它包含以下新型類的定義：
　　
　　清單 11. 新型類的定義
　　class Foo(object):
　　
　　def __init__(self, value):
　　self.value = value
　　
　　現在可以 pickle Foo 實例，並看一下它的表示：
　　
　　清單 12. pickle Foo 實例
　　>>> import cPickle as pickle
　　>>> from Orbtech.examples.persist import Foo
　　>>> foo = Foo('What is a Foo?')
　　>>> p = pickle.dumps(foo)
　　>>> print p
　　ccopy_reg
　　_reconstructor
　　p1
　　(cOrbtech.examples.persist
　　Foo
　　p2
　　c__builtin__
　　object
　　p3
　　NtRp4
　　(dp5
　　S'value'
　　p6
　　S'What is a Foo?'
　　sb.
　　>>>
　　
　　可以看到這個類的名稱 Foo 和全限定的模塊名稱 Orbtech.examples.persist 都存儲在 pickle 中。如果將這個實例 pickle 成一個文件，稍後再 unpickle 它或在另一台機器上 unpickle，則 Python 會試圖導入 Orbtech.examples.persist 模塊，如果不能導入，則會拋出異常。如果重命名該類和該模塊或者將該模塊移到另一個目錄，則也會發生類似的錯誤。
　　
　　這裡有一個 Python 發出錯誤消息的示例，當我們重命名 Foo 類，然後試圖裝入先前進行過 pickle 的 Foo 實例時會發生該錯誤：
　　
　　清單 13. 試圖裝入一個被重命名的 Foo 類的經過 pickle 的實例
　　>>> import cPickle as pickle
　　>>> f = file('temp.pkl', 'r')
　　>>> foo = pickle.load(f)
　　Traceback (most recent call last):
　　File "", line 1, in ?
　　AttributeError: 'module' object has no attribute 'Foo'
　　
　　在重命名 persist.py 模塊之後，也會發生類似的錯誤：
　　
　　清單 14. 試圖裝入一個被重命名的 persist.py 模塊的經過 pickle 的實例
　　>>> import cPickle as pickle
　　>>> f = file('temp.pkl', 'r')
　　>>> foo = pickle.load(f)
　　Traceback (most recent call last):
　　File "", line 1, in ?
　　ImportError: No module named persist
　　
　　我們會在下面模式改進這一節提供一些技術來管理這類更改，而不會破壞現有的 pickle。
　　
　　特殊的狀態方法
　　前面提到對一些對象類型（譬如，文件對象）不能進行 pickle。處理這種不能 pickle 的對象的實例屬性時可以使用特殊的方法（_getstate_() 和 _setstate_()）來修改類實例的狀態。這裡有一個 Foo 類的示例，我們已經對它進行了修改以處理文件對象屬性：
　　
　　清單 15. 處理不能 pickle 的實例屬性
　　class Foo(object):
　　
　　def __init__(self, value, filename):
　　self.value = value
　　self.logfile = file(filename, 'w')
　　
　　def __getstate__(self):
　　"""Return state values to be pickled."""
　　f = self.logfile
　　return (self.value, f.name, f.tell())
　　
　　def __setstate__(self, state):
　　"""Restore state from the unpickled state values."""
　　self.value, name, position = state
　　f = file(name, 'w')
　　f.seek(position)
　　self.logfile = f
　　
　　pickle Foo 的實例時，Python 將只 pickle 當它調用該實例的 _getstate_() 方法時返回給它的值。類似的，在 unpickle 時，Python 將提供經過 unpickle 的值作為參數傳遞給實例的 _setstate_() 方法。在 _setstate_() 方法內，可以根據經過 pickle 的名稱和位置信息來重建文件對象，並將該文件對象分配給這個實例的 logfile 屬性。
　　
　　模式改進
　　隨著時間的推移，您會發現自己必須要更改類的定義。如果已經對某個類實例進行了 pickle，而現在又需要更改這個類，則您可能要檢索和更新那些實例，以便它們能在新的類定義下繼續正常工作。而我們已經看到在對類或模塊進行某些更改時，會出現一些錯誤。幸運的是，pickle 和 unpickle 過程提供了一些 hook，我們可以用它們來支持這種模式改進的需要。
　　
　　在這一節，我們將探討一些方法來預測常見問題以及如何解決這些問題。由於不能 pickle 類實例代碼，因此可以添加、更改和除去方法，而不會影響現有的經過 pickle 的實例。出於同樣的原因，可以不必擔心類的屬性。您必須確保包含類定義的代碼模塊在 unpickle 環境中可用。同時還必須為這些可能導致 unpickle 問題的更改做好規劃，這些更改包括：更改類名、添加或除去實例的屬性以及改變類定義模塊的名稱或位置。
　　
　　類名的更改
　　要更改類名，而不破壞先前經過 pickle 的實例，請遵循以下步驟。首先，確保原來的類的定義沒有被更改，以便在 unpickle 現有實例時可以找到它。不要更改原來的名稱，而是在與原來類定義所在的同一個模塊中，創建該類定義的一個副本，同時給它一個新的類名。然後使用實際的新類名來替代 NewClassName，將以下方法添加到原來類的定義中：
　　
　　清單 16. 更改類名：添加到原來類定義的方法
　　def __setstate__(self, state):
　　self.__dict__.update(state)
　　self.__class__ = NewClassName
　　
　　當 unpickle 現有實例時，Python 將查找原來類的定義，並調用實例的 _setstate_() 方法，同時將給新的類定義重新分配該實例的 _class_ 屬性。一旦確定所有現有的實例都已經 unpickle、更新和重新 pickle 后，可以從源代碼模塊中除去舊的類定義。
　　
　　屬性的添加和刪除
　　這些特殊的狀態方法 _getstate_() 和 _setstate_() 再一次使我們能控制每個實例的狀態，並使我們有機會處理實例屬性中的更改。讓我們看一個簡單的類的定義，我們將向其添加和除去一些屬性。這是是最初的定義：
　　
　　清單 17. 最初的類定義
　　class Person(object):
　　
　　def __init__(self, firstname, lastname):
　　self.firstname = firstname
　　self.lastname = lastname
　　
　　假定已經創建並 pickle 了 Person 的實例，現在我們決定真的只想存儲一個名稱屬性，而不是分別存儲姓和名。這裡有一種方式可以更改類的定義，它將先前經過 pickle 的實例遷移到新的定義：
　　
　　清單 18. 新的類定義
　　class Person(object):
　　
　　def __init__(self, fullname):
　　self.fullname = fullname
　　
　　def __setstate__(self, state):
　　if 'fullname' not in state:
　　first = '
　　last = '
　　if 'firstname' in state:
　　first = state['firstname']
　　del state['firstname']
　　if 'lastname' in state:
　　last = state['lastname']
　　del state['lastname']
　　self.fullname = " ".join([first, last]).strip()
　　self.__dict__.update(state)
　　
　　在這個示例，我們添加了一個新的屬性 fullname，併除去了兩個現有的屬性 firstname 和 lastname。當對先前進行過 pickle 的實例執行 unpickle 時，其先前進行過 pickle 的狀態會作為字典傳遞給 _setstate_()，它將包括 firstname 和 lastname 屬性的值。接下來，將這兩個值組合起來，並將它們分配給新屬性 fullname。在這個過程中，我們刪除了狀態字典中舊的屬性。更新和重新 pickle 先前進行過 pickle 的所有實例之後，現在可以從類定義中除去 _setstate_() 方法。
　　
　　模塊的修改
　　在概念上，模塊的名稱或位置的改變類似於類名稱的改變，但處理方式卻完全不同。那是因為模塊的信息存儲在 pickle 中，而不是通過標準的 pickle 介面就可以修改的屬性。事實上，改變模塊信息的唯一辦法是對實際的 pickle 文件本身執行查找和替換操作。至於如何確切地去做，這取決於具體的操作系統和可使用的工具。很顯然，在這種情況下，您會想備份您的文件，以免發生錯誤。但這種改動應該非常簡單，並且對二進位 pickle 格式進行更改與對文本 pickle 格式進行更改應該一樣有效。
　　
　　結束語
　　對象持久性依賴於底層編程語言的對象序列化能力。對於 Python 對象即意味著 pickle。Python 的 pickle 為 Python 對象有效的持久性管理提供了健壯的和可靠的基礎。在下面的參考資料中，您將會找到有關建立在 Python pickle 能力之上的系統的信息。

Tags: linux system 內核