python:序列與模組,python:序列模組

來源:互聯網
上載者:User

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=0
View 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__必須與*連用

聯繫我們

該頁面正文內容均來源於網絡整理,並不代表阿里雲官方的觀點,該頁面所提到的產品和服務也與阿里云無關,如果該頁面內容對您造成了困擾,歡迎寫郵件給我們,收到郵件我們將在5個工作日內處理。

如果您發現本社區中有涉嫌抄襲的內容,歡迎發送郵件至: info-contact@alibabacloud.com 進行舉報並提供相關證據,工作人員會在 5 個工作天內聯絡您,一經查實,本站將立刻刪除涉嫌侵權內容。

A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

  • Sales Support

    1 on 1 presale consultation

  • After-Sales Support

    24/7 Technical Support 6 Free Tickets per Quarter Faster Response

  • Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.