Python學習：標準庫之資料持久存盤與交換

持久存盤資料以便長期使用包括兩個方面：在物件的記憶體中表示和存盤格式之間來回轉換資料，以及處理轉換后資料的存盤區，

標準庫包含很多模塊可以處理不同情況下的這兩個方面

有兩個模塊可以將物件轉換為一種可傳輸或存盤的格式(這個程序被稱為序列化)，最常用的是使用pickle持久存盤，因為它可以與其他一些具體存盤序列化資料的模塊集成，如shelve，
而對基于web的應用，json更為常用，因為它能更好地與現有的web服務存盤工具集成

一旦將記憶體中物件轉化為一種可保存的格式，那么下一步就是確定如何存盤這個資料，如果資料不需要以某種方式索引，則按照順序先后寫入序列化物件即可，
Python包括一組模塊可以在一個簡單的資料庫中存盤鍵值對，需要索引查找時會使用某種DBM變形格式

要利用DBM的格式，最直接的方式是使用shelve，可以打開shelve檔案，通過一個類似字典的API來訪問，

保存到資料庫的物件會自動"腌制"并保存，而無須呼叫者做任何額外的作業

不過shelve有一個缺點，使用默認介面時，沒有辦法預測將使用哪一個DBM格式，因為shelve會根據創建資料庫的系統上有哪些可用的庫來選擇一個格式，

如果應用不需要在配置有不同的庫的主機之間共享資料庫檔案，那么選擇哪一種并不重要，不過，如果必須保證可移植性，則可以使用這個模塊中的某個類來確保選擇一個特定的格式

對于web應用，由于這些應用已經在處理json格式的資料，因此可以使用json和dbm提供另一種持久存盤機制，

直接使用dbm會比使用shelve多做一些作業，因為DBM資料庫鍵和值都必須是字串，，而且在資料庫中訪問值時不會自動創建物件，

還有xml，csv等格式

一、pickle：物件序列化

import pickle
'''
pickle模塊實作了一個演算法，可以將一個Python物件轉換為一系列位元組，這個程序被稱為序列化，
可以傳輸或存盤表示物件的位元組流，然后再重新構造來創建有相同性質的新物件，
'''
 
# 注意：
'''
pickle的檔案明確指出它不提供任何安全保證，實際上，對資料解除"腌制"(反序列化)可以執行任意的代碼，
使用pickle模塊完成行程間通信或資料存盤時要當心，另外不要相信未經過安全驗證的資料，
'''

1.編碼和解碼字串中的資料

import pickle
'''
可以使用dumps將Python中物件進行序列化，也可以使用loads將序列化的物件轉換成Python中的物件
'''
d = {"a": 1, "b": 2}
 
data_string = pickle.dumps(d)
print(data_string)
 
# 傳入序列化物件
data = https://www.cnblogs.com/xxpythonxx/p/pickle.loads(data_string)  # b'\x80\x03}q\x00(X\x01\x00\x00\x00aq\x01K\x01X\x01\x00\x00\x00bq\x02K\x02u.'
print(data["a"] + data["b"])  # 3
'''
dumps(python物件) --> 序列化物件
loads(序列化物件) --> Python物件
 
默認地，pickle將以一種二進制格式寫入，在Python3程式之間共享時這種兼容性最好
 
資料序列化后，可以寫到一個檔案、套接字、管道或者其它位置，之后可以讀取這個檔案，將檔案進行反序列化，以便用同樣的值構造一個新物件
'''
 
 
# 注意：可以序列化Python中的大部分常見物件
class A:
    a = "aaa"
 
 
a = A()
obj = pickle.dumps(a)
# 反序列化之后的物件和原來的物件是一樣的，但是不是同一個物件
print(pickle.loads(obj) is a)  # False
print(pickle.loads(obj).a)  # aaa
 
 
# 除此之外，pickle還可以將序列化dump到一個檔案里,然后從檔案里面load
'''
函式分別是dump和load
pickle.dump(python物件, f)
pickle.load(f)
 
和不涉及檔案的dumps、loads類似
pickle.dumps(Python物件)  -->會有回傳值，obj
pickle.loads(obj)
 
操作類似，不再演示
'''

2.處理流

import pickle
import io
'''
除了dumps、loads，pickle還提供了一些便利的函式來處理類似檔案的流，
可以向一個流寫多個物件，然后從流讀取這些物件，而無須事先知道要寫多個物件或者這些物件有多大，
'''
d = {"a": 1, "b": 2}
l = [1, 2, 3]
s = {1, 1, 3}
data = [d, l, s]
 
out_s = io.BytesIO()
for o in data:
    pickle.dump(o, out_s)
    out_s.flush()
 
in_s = io.BytesIO(out_s.getvalue())
 
while True:
    try:
        o = pickle.load(in_s)
        print(o)
    except EOFError:
        break
'''
{'a': 1, 'b': 2}
[1, 2, 3]
{1, 3}
'''

3.重構物件的問題

import pickle
import sys
'''
處理定制類時，腌制的類必須出現在讀取pickle的行程所在的命名空間里，
只會腌制這個實體的資料，而不是類定義，類名用于查找建構式，以便在解除腌制時創建新物件，
 
比如我在A.py中定義了一個類Foo，然后將其實體物件序列化，
我在B.py中將其反序列化，是會報錯的，因為根本就有沒有Foo這個類，如果from A import Foo之后，那么便不會報錯，
說明腌制的類必須出現在讀取pickle的行程所在的命名空間里
'''

4.不可腌制的物件

import pickle
'''
并不是所有物件都是可腌制的，套接字、檔案句柄、資料庫連接以及其他運行時狀態依賴于作業系統或其他行程的物件，其可能無法用一種有意義的方式保存，
如果物件包含不可腌制的屬性，則可以定義__getstate__和__setstate__來回傳所腌制實體的狀態的一個子集
 
__getstate__方法必須回傳一個物件，其中包含所腌制物件的內部狀態，表示狀態的一種便利方式是使用字典，不過值可以是任意的可腌制物件，
保存狀態，然后在從pickle加載物件時將所保存的狀態傳入__setstate__
'''
 
 
class A:
 
    def __init__(self):
        self.name = "mashiro"
        self.age = 16
 
    def __getstate__(self):
        print("__getstate__")
        return {"name": self.name, "age": self.age}
 
    def __setstate__(self, state):
        print("__setstate__")
        print(state)
 
 
a = A()
# 當dumps的時候，會觸發__getstate__方法，要有一個回傳值
dump_obj = pickle.dumps(a)  # __getstate__
# 當loads的時候，會觸發__setstate__方法，__getstate__方法的回傳值會傳給state
load_obj = pickle.loads(dump_obj)
'''
__setstate__
{'name': 'mashiro', 'age': 16}
'''
  
# 而且pickle協議會自動處理物件之間的回圈參考，所以復雜資料結構不需要任何特殊的處理，

5.dbm：Unix-鍵值資料庫

'''
在一些小型程式中，不需要關系型資料庫時，可以方便的用持久字典來存盤鍵值對，和python中的字典非常類似，而且dbm的鍵和值都必須是str或者bytes型別
'''
import dbm
  
'''
這里第一個引數直接傳入檔案名，第二個引數表示模式
常見的模式：
r：可讀，默認就是這個模式
w：可讀可寫
但是r、w，都必須確保檔案已經存在，否則報錯，
  
c：可讀可寫，檔案不存在時會創建
n：可讀可寫，但總是會創建一個新的檔案，也就是說如果創建同名檔案，那么之前的內容都會被清空，也就是起不到追加的效果，
  
因此我們平常的模式一般都會選擇c
  
  
第三個引數是權限，這個在windows下基本不用，是一組用八進制表示的數字，默認是0o666，都是可讀可寫不可執行
'''
db = dbm.open("store", "c")
  
# 打開檔案之后，就可以存盤值了
# 注意key和value都必須是str或者bytes型別
db["name"] = "satori"
db["age"] = "16"
db["gender"] = "f"
db["anime"] = "東方地靈殿"
  
# 關閉檔案，將內容寫到磁盤上
db.close()
  
  
################################################################
# 打開檔案
db = dbm.open("store", "c")
print(db.keys())  # [b'name', b'age', b'gender', b'anime']
for key in db.keys():
    print(f"key={key}, value=https://www.cnblogs.com/xxpythonxx/p/{db[key]}")
    '''
    key=b'name', value=https://www.cnblogs.com/xxpythonxx/p/b'satori'
    key=b'age', value=https://www.cnblogs.com/xxpythonxx/p/b'16'
    key=b'gender', value=https://www.cnblogs.com/xxpythonxx/p/b'f'
    key=b'anime', value=https://www.cnblogs.com/xxpythonxx/p/b'\xe4\xb8\x9c\xe6\x96\xb9\xe5\x9c\xb0\xe7\x81\xb5\xe6\xae\xbf'
    '''

會多出這么三個檔案

6.shelve：物件的持久存盤

''' 
shelve和dbm比較類似，但是功能遠比dbm強大，因為它可以持久化任意物件
'''
import shelve
  
# 引數flag默認是c,因此我們只需要傳入檔案名就可以了，這個是自動追加在后面的
# 也就是說我寫完之后，再次打開繼續寫的話，只會追加不會清空
sh = shelve.open("shelve")
  
sh["dict"] = {"name": "satori", "age": 16}
sh["list"] = [1, 2, 3, 4]
sh["set"] = {1, 2, 3, 2}
  
# 寫完之后關閉檔案，刷到記憶體里面
# 關閉之后就無法操作了
sh.close()
  
  
# 下面我們就可以操作資料了，下面的代碼即便寫在另一個py檔案里面也是可以的
sh2 = shelve.open("shelve")
print(sh2["dict"], sh2["dict"].keys())  # {'name': 'satori', 'age': 16} dict_keys(['name', 'age'])
print(sh2["list"], sum(sh2["list"]))  # [1, 2, 3, 4] 10
print(sh2["set"])  # {1, 2, 3}
sh2.close()
  
  
# 可以看到，拿出來的就是原生的物件，可以直接用來進行操作的，那我們看看自己定義的類可不可以呢？
sh3 = shelve.open("shelve")
  
  
class A:
    def __init__(self, name, age):
        self.name = name
        self.age = age
  
    @property
    def print_info(self):
        return f"my name is {self.name}, age is {self.age}"
  
  
a = A("satori", 16)
# 將這個類和類的一個實體物件存盤進去
sh3["A"] = A
sh3["a"] = a
sh3.close()
  
  
######################################
sh4 = shelve.open("shelve")
  
# sh4["A"]拿到A這個類，傳入引數，呼叫方法
print(sh4["A"]("mashiro", "17").print_info)  # my name is mashiro, age is 17
  
# sh4["a"]拿到a這個實體物件，直接呼叫方法
print(sh4["a"].print_info)  # my name is satori, age is 16
  
# 我們發現依舊是可以的，說明了shelve這個模塊真的很強大

我們再來看一個例子

'''
學習中遇到問題沒人解答？小編創建了一個Python學習交流群：711312441
尋找有志同道合的小伙伴，互幫互助,群里還有不錯的視頻學習教程和PDF電子書！
'''
import shelve
  
sh = shelve.open("shelve")
sh["list"] = [1, 2, 3]
sh["str"] = "mashiro"
sh.close()
  
##############################
sh = shelve.open("shelve")
sh["list"].append("xxxx")
sh["str"] = "satori"
sh.close()
  
#######################
sh = shelve.open("shelve")
print(sh["list"])  # [1, 2, 3]
print(sh["str"])  # satori

分析結果，第一次打開檔案我們創建兩個鍵值對

sh["list"] = [1, 2, 3]
sh["str"] = "mashiro"

第二次打開檔案，修改了兩個鍵的值
第三次打開檔案，列印，但是我們發現sh["str"]改變了，但是sh["list"]沒有改變，這是為什么？
首先sh["str"] = "satori"很好理解，但是為什么sh["list"]沒有變？
因為=，我們是直接賦值，將這一塊記憶體里面的值給換掉，而sh["list"]我們是做append操作，這只是在原來的基礎上進行修改shelve默認情況下是不會記錄，持久化物件的修改的，除非你是創建新的物件，或者是把原來的物件給換掉，如果是在原來的基礎上(可變型別),比如串列、字典，進行添加或者洗掉操作，這些是不會被記錄的
所以：sh["list"]=[1, 2, 3] sh["list"].append("xxxx") --->sh["list"]仍是[1, 2, 3]不會是[1, 2, 3, "xxx"]
因為shelve沒有記錄物件自身的修改，如果我想得到期望的結果，一種方法是把物件整體換掉sh["list"] = [1, 2, 3, "xxxx"]，這樣等于是重新賦值，是可行的，但是有時候我們不知道串列里面內容，或者串列里面的內容是一些函式、類什么的、不好寫的話，該咋辦呢？

其實我們在打開檔案的時候，還可以加上一個引數，叫做writeback

import shelve
  
sh = shelve.open("shelve")
sh["list"] = [1, 2, 3]
sh["str"] = "mashiro"
sh.close()
  
##############################
# 如果我們需要進行修改，那么加上一個writeback=True就可以了，從名字也能看出來
# 這是會將修改的內容從新寫回去
sh = shelve.open("shelve", writeback=True)
sh["list"].append("xxxx")
sh["str"] = "satori"
sh.close()
  
#######################
sh = shelve.open("shelve")
print(sh["list"])  # [1, 2, 3, 'xxxx']
print(sh["str"])  # satori
'''
可以看到都發生改變了，但是這個引數有缺陷，就是會有額外的記憶體消耗，當我們加上writeback=True的時候shelve會將我們讀取的物件都放到一個記憶體快取當中，
比如說我們獲取了20持久化的物件，但是我們只修改了一個，剩余的19個只是查看并沒有做修改，但當我們sh.close()的時候，會將這20個物件都寫回去
因為shelve不知道你會對哪個物件進行修改，于是不管你是查看還是修改，都會放到快取當中，然后再一次性都寫回去，
這樣會造成兩點：
1.物件放到記憶體快取當中，等于是重新拷貝了一份，因為我們讀取檔案已經到記憶體當中了，而shelve又把我們使用的物件放到記憶體的另一片空間中
2.寫入資料，我們明明只修改了一份資料，但是它把20份都重新寫回去了，這樣會造成性能上的問題，導致效率會降低，
因此加不加這個引數，由具體情況決定
'''

標籤：Python

上一篇：Python爬蟲之基于selenium實作12306模擬登錄

下一篇：在*args, **kwargs上強制規定引數的呼叫約定