求值 acl modules pickle模塊 內存 會有 dll oca 學習

一，序列化模塊

什麽叫序列化——將原本的字典、列表等內容轉換成一個字符串的過程就叫做序列化。

比如，我們在python代碼中計算的一個數據需要給另外一段程序使用，那我們怎麽給？
現在我們能想到的方法就是存在文件裏，然後另一個python程序再從文件裏讀出來。
但是我們都知道，對於文件來說是沒有字典這個概念的，所以我們只能將數據轉換成字典放到文件中。
你一定會問，將字典轉換成一個字符串很簡單，就是str(dic)就可以辦到了，為什麽我們還要學習序列化模塊呢？
沒錯序列化的過程就是從dic 變成str(dic)的過程。現在你可以通過str(dic)的方法，將一個名為dic的字典轉換成一個字符串，
但是你要怎麽把一個字符串轉換成字典呢？
聰明的你肯定想到了eval()，如果我們將一個字符串類型的字典str_dic傳給eval，就會得到一個返回的字典類型了。
eval()函數十分強大，但是eval是做什麽的？eval官方demo解釋為：將字符串str當成有效的表達式來求值並返回計算結果。
ＢＵＴ！強大的函數有代價。安全性是其最大的缺點。
想象一下，如果我們從文件中讀出的不是一個數據結構，而是一句
 
"刪除文件"類似的破壞性語句，那麽後果實在不堪設設想。
而使用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
 
 json
str_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 load
dic = {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的方法是直接在文件裏讀寫數據類型。

4）ensure_ascii關鍵字參數

import json
f = 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 json
data = {‘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、load 1)pickle 的dumps和loads

import pickle
dic = {‘k1‘:‘v1‘,‘k2‘:‘v2‘,‘k3‘:‘v3‘}
str_dic = pickle.dumps(dic)
print(str_dic)  #一串二進制內容

dic2 = pickle.loads(str_dic)
print(dic2)    #字典

2）分步dump與load

import time
struct_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方法，是用key來訪問的，使用起來和字典類似

import shelve
f = shelve.open(‘shelve_file‘)
f[‘key‘] = {‘int‘:10, ‘float‘:9.5, ‘string‘:‘Sample data‘}  #直接對文件句柄操作，就可以存入數據
f.close()

import shelve
f1 = 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.py
print(‘from the my_module.py‘)

money=1000

def 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.py
import my_module #只在第一次導入時才執行my_module.py內代碼,此處的顯式效果是只打印一次‘from the my_module.py‘,當然其他的頂級代碼也都被執行了,只不過沒有顯示效果.
import my_module
import my_module
import my_module

‘‘‘
執行結果：
from the my_module.py
‘‘‘
#調用了多次但是只打印了一個結果

我們可以從sys.modules中找到當前已經加載的模塊，sys.modules是一個字典，內部包含模塊名與模塊對象的映射，該字典決定了導入模塊時是否需要重新導入。

2）每個模塊都是一個獨立的名稱空間，定義在這個模塊中的函數，把這個模塊的名稱空間當做全局名稱空間，這樣我們在編寫自己的模塊時，就不用擔心我們定義在自己模塊中全局變量會在被導入時，與使用者的全局變量沖突

#測試一:money與my_module.money不沖突
#demo.py
#my_module中：from the my_module.py
import my_module
money=10
print(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_module
def read1():
    print(‘========‘)
my_module.read1()

‘‘‘
執行結果:
from the my_module.py
my_module->read1->money 1000
‘‘‘                        

4)測試三：執行my_module.change()操作的全局變量money仍然是my_module中的

#測試三：執行my_module.change()操作的全局變量money仍然是my_module中的
#demo.py
import my_module
money=1
my_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 sm
print(sm.money)

示範用法一：

有兩中sql模塊mysql和oracle，根據用戶的輸入，選擇不同的sql功能

#mysql.py
def sqlparse():
    print(‘from mysql sqlparse‘)
#oracle.py
def sqlparse():
    print(‘from oracle sqlparse‘)

#test.py
db_type=input(‘>>: ‘)
if db_type == ‘mysql‘:
    import mysql as db
elif db_type == ‘oracle‘:
    import oracle as db

db.sqlparse() 
復制代碼

4,from ... import...

from my_module import read1,read2
這樣在當前位置直接使用read1和read2就好了，執行時，仍然以my_module.py文件全局名稱空間

from demo import money,read
print(money)
read()
money = 200
read()

#測試一：導入的函數read1，執行時仍然回到my_module.py中尋找全局變量money
#demo.py
from my_module import read1
money=1000
read1()
‘‘‘
執行結果:
from the my_module.py
spam->read1->money 1000
‘‘‘

#測試二:導入的函數read2，執行時需要調用read1(),仍然回到my_module.py中找read1()
#demo.py
from my_module import read2
def read1():
    print(‘==========‘)
read2()

‘‘‘
執行結果:
from the my_module.py
my_module->read2 calling read1
my_module->read1->money 1000
‘‘‘

這樣在當前位置直接使用read1和read2就好了，執行時，仍然以my_module.py文件全局名稱空間

如果當前有重名read1或者read2，那麽會有覆蓋效果

#測試三:導入的函數read1，被當前位置定義的read1覆蓋掉了
#demo.py
from my_module import read1
def read1():
    print(‘==========‘)
read1()
‘‘‘
執行結果:
from the my_module.py
==========
‘‘‘

需要特別強調的一點是：python中的變量賦值不是一種存儲操作，而只是一種綁定關系，如下:

from my_module import money,read1
money=100 #將當前位置的名字money綁定到了100
print(money) #打印當前的名字
read1() #讀取my_module.py中的名字money,仍然為1000

‘‘‘
from the my_module.py
my_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路徑中包含的模塊

需要特別註意的是：我們自定義的模塊名不應該與系統內置模塊重名。雖然每次都說，但是仍然會有人不停的犯錯。

python：序列、模塊