python:序列與模組,python:序列模組
一,序列化模組
什麼叫序列化——將原本的字典、列表等內容轉換成一個字串的過程就叫做序列化。
比如,我們在python代碼中計算的一個資料需要給另外一段程式使用,那我們怎麼給?現在我們能想到的方法就是存在檔案裡,然後另一個python程式再從檔案裡讀出來。但是我們都知道,對於檔案來說是沒有字典這個概念的,所以我們只能將資料轉換成字典放到檔案中。你一定會問,將字典轉換成一個字串很簡單,就是str(dic)就可以辦到了,為什麼我們還要學習序列化模組呢?沒錯序列化的過程就是從dic 變成str(dic)的過程。現在你可以通過str(dic)的方法,將一個名為dic的字典轉換成一個字串,但是你要怎麼把一個字串轉換成字典呢?聰明的你肯定想到了eval(),如果我們將一個字串類型的字典str_dic傳給eval,就會得到一個返回的字典類型了。eval()函數十分強大,但是eval是做什麼的?eval官方demo解釋為:將字串str當成有效運算式來求值並返回計算結果。BUT!強大的函數有代價。安全性是其最大的缺點。想象一下,如果我們從檔案中讀出的不是一個資料結構,而是一句"刪除檔案"類似的破壞性語句,那麼後果實在不堪設設想。而使用eval就要擔這個風險。所以,我們並不推薦用eval方法來進行還原序列化操作(將str轉換成python中的資料結構)
為什麼要進行序列化
序列化的目的
1、以某種儲存形式使自訂對象持久性;2、將對象從一個地方傳遞到另一個地方。3、使程式更具維護性。
1,json模組
Json模組提供了四個功能:dumps、dump、loads、load
1)dumps和loads
#json dumps序列化方法 loads還原序列化方法dic = {1:"a",2:'b'}print(type(dic),dic)import jsonstr_d = json.dumps(dic) # 序列化print(type(str_d),str_d)# '{"kkk":"v"}'#注意:kkk用" "(雙引號引起來了)dic_d = json.loads(str_d) # 還原序列化print(type(dic_d),dic_d)'''<class 'dict'> {1: 'a', 2: 'b'}<class 'str'> {"1": "a", "2": "b"}<class 'dict'> {'1': 'a', '2': 'b'}'''dumps和loads
dumps是序列化方法,loads還原序列化方法
2)dump與load
import json# json dump loaddic = {1:"a",2:'b'}f = open('fff','w',encoding='utf-8')json.dump(dic,f)f.close()f = open('fff')res = json.load(f)f.close()print(type(res),res)'''<class 'dict'> {'2': 'b', '1': 'a'}'''dump和load
3)dumps、loads與dump、load的區別
有s的直接在記憶體操作資料類型,沒有s的方法是直接在檔案裡讀寫資料類型。
dump需要需要有檔案控制代碼,load不能進行多次load。
4)ensure_ascii關鍵字參數
import jsonf = open('file','w')json.dump({'國籍':'中國'},f)ret = json.dumps({'國籍':'中國'})f.write(ret+'\n')json.dump({'國籍':'美國'},f,ensure_ascii=False)ret = json.dumps({'國籍':'美國'},ensure_ascii=False)f.write(ret+'\n')f.close()ensure_ascii關鍵字參數
5)json格式化輸出
import jsondata = {'username':['李華','二愣子'],'sex':'male','age':16}json_dic2 = json.dumps(data,sort_keys=True,indent=2,separators=(',',':'),ensure_ascii=False)print(json_dic2)json格式化輸出
2,pickle
#所有的python中的資料類型都可以轉化成字串形式 #pickle序列化的內容只有python能理解 #且部分還原序列化依賴python代碼 #可以分步dump和分步load #序列化與反序列話需要相同的環境pickle模組提供了四個功能:dumps、dump、loads、load1)pickle 的dumps和loads
import pickledic = {'k1':'v1','k2':'v2','k3':'v3'}str_dic = pickle.dumps(dic)print(str_dic) #一串二進位內容dic2 = pickle.loads(str_dic)print(dic2) #字典
2)分步dump與load
dump和load必須用wb和rb開啟
import timestruct_time1 = time.localtime(1000000000)struct_time2 = time.localtime(2000000000)f = open('pickle_file','wb')pickle.dump(struct_time1,f)pickle.dump(struct_time2,f)f.close()f = open('pickle_file','rb')struct_time1 = pickle.load(f)struct_time2 = pickle.load(f)print(struct_time1.tm_year)print(struct_time2.tm_year)f.close()分步dump和分步load
3,shelve
#序列化控制代碼 #使用控制代碼直接操作,非常方便shelve也是python提供給我們的序列化工具,比pickle用起來更簡單一些shelve只提供給我們一個open方法,open方法擷取一個檔案控制代碼,操作和字典類似。是用key來訪問的,使用起來和字典類似。
import shelvef = shelve.open('shelve_file')f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'} #直接對檔案控制代碼操作,就可以存入資料f.close()
import shelvef1 = shelve.open('shelve_file')existing = f1['key'] #取出資料的時候也只需要直接用key擷取即可,但是如果key不存在會報錯f1.close()print(existing)
二、模組
1,什麼是模組?
一個模組就是一個包含了python定義和聲明的檔案,檔案名稱就是模組名字加上.py的尾碼。
2,import載入的模組分為四個通用類別:
1 使用python編寫的代碼(.py檔案)
2 已被編譯為共用庫或DLL的C或C++擴充
3 包好一組模組的包
4 使用C編寫並連結到python解譯器的內建模組
3,import
1)樣本檔案:自訂模組my_module.py,檔案名稱my_module.py,模組名my_module
#my_module.pyprint('from the my_module.py')money=1000def read1(): print('my_module->read1->money',money)def read2(): print('my_module->read2 calling read1') read1()def change(): global money money=0View Code
模組可以包含可執行檔語句和函數的定義,這些語句的目的是初始化模組,它們只在模組名第一次遇到匯入import語句時才執行(import語句是可以在程式中的任意位置使用的,且針對同一個模組很import多次,為了防止你重複匯入,python的最佳化手段是:第一次匯入後就將模組名載入到記憶體了,後續的import語句僅是對已經載入大記憶體中的模組對象增加了一次引用,不會重新執行模組內的語句)
#demo.pyimport my_module #只在第一次匯入時才執行my_module.py內代碼,此處的顯式效果是只列印一次'from the my_module.py',當然其他的頂級代碼也都被執行了,只不過沒有顯示效果.import my_moduleimport my_moduleimport my_module'''執行結果:from the my_module.py'''#調用了多次但是只列印了一個結果
我們可以從sys.modules中找到當前已經載入的模組,sys.modules是一個字典,內部包含模組名與模組對象的映射,該字典決定了匯入模組時是否需要重新匯入。
2)每個模組都是一個獨立的名稱空間,定義在這個模組中的函數,把這個模組的名稱空間當做全域名稱空間,這樣我們在編寫自己的模組時,就不用擔心我們定義在自己模組中全域變數會在被匯入時,與使用者的全域變數衝突
#測試一:money與my_module.money不衝突#demo.py#my_module中:from the my_module.pyimport my_modulemoney=10print(my_module.money)'''執行結果:from the my_module.py'''
3)測試二:read1與my_module.read1不衝突
#測試二:read1與my_module.read1不衝突#demo.py#my_module: #print('from the my_module.py') #def read1(): # print('money 1000') import my_moduledef read1(): print('========')my_module.read1()'''執行結果:from the my_module.pymy_module->read1->money 1000'''
4)測試三:執行my_module.change()操作的全域變數money仍然是my_module中的
#測試三:執行my_module.change()操作的全域變數money仍然是my_module中的#demo.pyimport my_modulemoney=1my_module.change()print(money)'''執行結果:from the my_module.py'''
5)
總結:首次匯入模組my_module時會做三件事:
1.為源檔案(my_module模組)建立新的名稱空間,在my_module中定義的函數和方法若是使用到了global時訪問的就是這個名稱空間。
2.在新建立的命名空間中執行模組中包含的代碼,見初始匯入import my_module
匯入模組時到底執行了什嗎?事實上函數定義也是“被執行”的語句,模組層級別函數定義的執行將函數名放入模組全域名稱空間表,用globals()可以查看
3.建立名字my_module來引用該命名空間
1 這個名字和變數名沒什麼區別,都是‘第一類的’,且使用my_module.名字的方式可以訪問my_module.py檔案中定義的名字,my_module.名字與test.py中的名字來自兩個完全不同的地方。
6)為模組名起別名,相當於m1=1;m2=m1
import my_module as smprint(sm.money)
示範用法一:
有兩中sql模組mysql和oracle,根據使用者的輸入,選擇不同的sql功能
#mysql.pydef sqlparse(): print('from mysql sqlparse')#oracle.pydef sqlparse(): print('from oracle sqlparse')#test.pydb_type=input('>>: ')if db_type == 'mysql': import mysql as dbelif db_type == 'oracle': import oracle as dbdb.sqlparse() 複製代碼
4,from ... import...
from my_module import read1,read2
這樣在當前位置直接使用read1和read2就好了,執行時,仍然以my_module.py檔案全域名稱空間
from demo import money,readprint(money)read()money = 200read()
#測試一:匯入的函數read1,執行時仍然回到my_module.py中尋找全域變數money#demo.pyfrom my_module import read1money=1000read1()'''執行結果:from the my_module.pyspam->read1->money 1000'''#測試二:匯入的函數read2,執行時需要調用read1(),仍然回到my_module.py中找read1()#demo.pyfrom my_module import read2def read1(): print('==========')read2()'''執行結果:from the my_module.pymy_module->read2 calling read1my_module->read1->money 1000'''這樣在當前位置直接使用read1和read2就好了,執行時,仍然以my_module.py檔案全域名稱空間
如果當前有重名read1或者read2,那麼會有覆蓋效果
#測試三:匯入的函數read1,被當前位置定義的read1覆蓋掉了#demo.pyfrom my_module import read1def read1(): print('==========')read1()'''執行結果:from the my_module.py=========='''
需要特彆強調的一點是:python中的變數賦值不是一種儲存操作,而只是一種綁定關係,如下:
from my_module import money,read1money=100 #將當前位置的名字money綁定到了100print(money) #列印當前的名字read1() #讀取my_module.py中的名字money,仍然為1000'''from the my_module.pymy_module->read1->money 1000'''
1)as
也支援as
from my_module import read1 as read
2)也支援多行輸入
from my_module import (read1, read2, money)
5,把模組當做指令碼執行
我們可以通過模組的全域變數__name__來查看模組名:
當做指令碼運行:
__name__ 等於'__main__'
當做模組匯入:
__name__= 模組名
作用:用來控制.py檔案在不同的應用情境下執行不同的邏輯
if __name__ == '__main__':
def fib(n): a, b = 0, 1 while b < n: print(b, end=' ') a, b = b, a+b print()if __name__ == "__main__": print(__name__) num = input('num :') fib(int(num))6模組搜尋路徑
python解譯器在啟動時會自動載入一些模組,可以使用sys.modules查看
在第一次匯入某個模組時(比如my_module),會先檢查該模組是否已經被載入到記憶體中(當前執行檔案的名稱空間對應的記憶體),如果有則直接引用
如果沒有,解譯器則會尋找同名的內建模組,如果還沒有找到就從sys.path給出的目錄列表中依次尋找my_module.py檔案。
所以總結模組的尋找順序是:記憶體中已經載入的模組->內建模組->sys.path路徑中包含的模組
需要特別注意的是:我們自訂的模組名不應該與系統內建模組重名。雖然每次都說,但是仍然會有人不停的犯錯。
模組總結:
1,import和from import都支援as重新命名,都支援多名字的匯入
2,一個模組被import匯入之後,並不會再次被匯入。因為sys.mouldes記錄了所有被匯入的模組
3,sys.path記錄了匯入模組的時候尋找的所有路徑
4,模組就是一個py檔案
5,__all__必須與*連用