Python序列化和反序列化

通過將對象序列化可以將其存儲在變量或者文件中，可以保存當時對象的狀態，實現其生命周期的延長。并且需要時可以再次將這個對象讀取出來。Python中有幾個常用模塊可實現這一功能。

pickle模塊

存儲在變量中

dumps(obj)返回存入的字節

dic = {'age': 23, 'job': 'student'}
byte_data = pickle.dumps(dic)
# out -> b'\x80\x03}q\x00(X\x03\x00\x00\...'
print(byte_data)

讀取數據

數據以字節保存在了byte_data變量中，需要再次使用的時候使用loads函數就行了。

obj = pickle.loads(byte_data)
print(obj)

存儲在文件中

也可以存在文件中，使得對象持久化。使用的是dump和load函數，注意和上面的區別，少了s。由于pickle寫入的是二進制數據，所以打開方式需要以wb和rb的模式。

# 序列化
with open('abc.pkl', 'wb') as f:
    dic = {'age': 23, 'job': 'student'}
    pickle.dump(dic, f)
# 反序列化
with open('abc.pkl', 'rb') as f:
    aa = pickle.load(f)
    print(aa)
    print(type(aa))  # <class 'dict'>

序列化用戶自定義對象

假如我寫了個類叫做Person

class Person:
    def __init__(self, name, age, job):
        self.name = name
        self.age = age
        self.job = job

    def work(self):
        print(self.name, 'is working...')

pickle當然也能寫入，不僅可以寫入類本身，也能寫入它的一個實例。

# 將實例存儲在變量中，當然也能存在文件中
a_person = Person('abc', 22, 'waiter')
person_abc = pickle.dumps(a_person)
p = pickle.loads(person_abc)
p.work()
# 將類本身存儲在變量中，loads的時候返回類本身，而非它的一個實例
class_Person = pickle.dumps(Person)
Person = pickle.loads(class_Person)
p = Person('Bob', 23, 'Student')
p.work()

# 下面這個例子演示的就是將類存儲在文件中
# 序列化
with open('person.pkl', 'wb') as f:
    pickle.dump(Person, f)
# 反序列化
with open('person.pkl', 'rb') as f:
    Person = pickle.load(f)
    aa = Person('gg', 23, '6')
    aa.work()

json模塊

pickle可以很方便地序列化所有對象。不過json作為更為標準的格式，具有更好的可讀性（pickle是二進制數據）和跨平臺性。是個不錯的選擇。

json使用的四個函數名和pickle一致。

序列化為字符串

dic = {'age': 23, 'job': 'student'}
dic_str = json.dumps(dic)
print(type(dic_str), dic_str)
# out: <class 'str'> {"age": 23, "job": "student"}

dic_obj = json.loads(dic_str)
print(type(dic_obj), dic_obj)
# out: <class 'dict'> {'age': 23, 'job': 'student'}

可以看到，dumps函數將對象轉換成了字符串。loads函數又將其恢復成字典。

存儲為json文件

也可以存儲在json文件中

dic = {'age': 23, 'job': 'student'}
with open('abc.json', 'w', encoding='utf-8') as f:
    json.dump(dic, f)

with open('abc.json', encoding='utf-8') as f:
    obj = json.load(f)
    print(obj)

存儲自定義對象

還是上面的Person對象。如果直接序列化會報錯

aa = Person('Bob', 23, 'Student')
with open('abc.json', 'w', encoding='utf-8') as f:
    json.dump(aa, f) # 報錯

Object of type 'Person' is not JSON serializable此時dump函數里傳一個參default就可以了，這個參數接受一個函數，這個函數可以將對象轉換為字典。

寫一個就是了

def person2dict(person):
    return {'name': person.name,
            'age': person.age,
            'job': person.job}

這樣返回的就是一個字典了，對象實例有個方法可以簡化這一過程。直接調用實例的__dict__。例如

print(aa.__dict) # {'name': 'Bob', 'age': 23, 'job': 'Student'}

很方便。

同時在讀取的時候load出來的是一個字典，再轉回對象就可，同樣需要一個object_hook參數，該參數接收一個函數，用于將字典轉為對象。

def dict2person(dic):
    return Person(dic['name'], dic['age'], dic['job'])

于是完整的程序應該寫成下面這樣

with open('abc.json', 'w', encoding='utf-8') as f:
    json.dump(aa, f, default=person2dict)

with open('abc.json', encoding='utf-8') as f:
    obj = json.load(f, object_hook=dict2person)
    print(obj.name, obj.age, obj.job)
    obj.work()

由于可以使用__dict__代替person2dict函數，再使用lambda函數簡化。

with open('abc.json', 'w', encoding='utf-8') as f:
   json.dump(aa, f, default=lambda obj: obj.__dict__)

以上是存儲到文件，存儲到變量也是類似操作。

不過就我現在所學，不知道如何像pickle一樣方便的將我們自定義的類本身使用json序列化，或許要用到其他擴展函數。以后用到了再說。

shelve模塊

還有一個模塊，不太常用，通常使用一個open就好。shelve以鍵值對的形式存儲數據。

with shelve.open('aa') as f:
    f['person'] = {'age': 23, 'job': 'student'}
    f['person']['age'] = 44  # 這里試圖改變原來的年齡23
    f['numbers'] = [i for i in range(10)]

with shelve.open('aa') as f:
    person = f['person']
    print(person) # {'age': 23, 'job': 'student'}
    nums = f['numbers']
    print(nums) # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

文件不要有后綴名，在windows下會生成aa.bak, aa.dat, aa.dir三個文件（有點多）。其中bak和dir文件是可以查看的（貌似兩個文件內容一樣）在下面這個例子中生成這樣的數據。

'person', (0, 44)
'numbers', (512, 28)

允許寫回--writeback

有個細節，我們讀取鍵person時候，發現age還是23歲，f['person']['age'] = 44后并沒有變成44。下面的寫法

with shelve.open('aa', writeback=True) as f:
    dic = {'age': 23, 'job': 'student'}
    f['person'] = dic
    dic['age'] = 44
    f['person'] = dic

相當于賦值了兩次，這種方法是可以改變值的。

默認情況下直接使用f['person']改變其中的值之后，不會更新已存儲的值，也就是沒有把更新寫回到文件，即使是文件被close后。如果有此需要，在open函數中添加一個參數writeback=True。再次運行下看看年齡就被改變了。

寫入自定義對象

依然使用上面的Person對象

with shelve.open('aa') as f:
    f['class'] = Person
    
# 寫入類本身
with shelve.open('aa') as f:
    Person = f['class']
    a = Person('Bob', 23, 'Student')
    a.work()

上面的例子說明shelve也可以序列化類本身。當然序列化實例肯定可以。

with shelve.open('aa') as f:
    a = Person('God', 100, 'watch')
    f['class'] = a

with shelve.open('aa') as f:
    god = f['class']
    god.work()

注意，由于我們使用with open打開，故不用寫close語句，此模塊是有close函數的，如果不是with方法打開的一定要記得主動close。

by @sunhaiyu

2017.6.27