018_序列化模塊_什麼是模塊

1，序列化模塊
　　什麼叫序列化——將本來的字典、列表等內容轉換成一個字符串的過程就叫作序列化。
　　好比，咱們在python代碼中計算的一個數據須要給另一段程序使用，那咱們怎麼給？如今咱們能想到的方法就是存在文件裏，而後另外一個python程序再從文件裏讀出來。可是咱們都知道，對於文件來講是沒有字典這個概念的，因此咱們只能將數據轉換成字符串放到文件中。你必定會問，將字典轉換成一個字符串很簡單，就是str(dic)就能夠辦到了，爲何咱們還要學習序列化模塊呢？沒錯序列化的過程就是從dic 變成str(dic)的過程。如今你能夠經過str(dic)，將一個名爲dic的字典轉換成一個字符串，可是你要怎麼把一個字符串轉換成字典呢？
　　聰明的你確定想到了eval()，若是咱們將一個字符串類型的字典str_dic傳給eval，就會獲得一個返回的字典類型了。eval()函數十分強大，可是eval是作什麼的？官方demo解釋爲：將字符串str當成有效的表達式來求值並返回計算結果。ＢＵＴ！強大的函數有代價。安全性是其最大的缺點。想象一下，若是咱們從文件中讀出的不是一個數據結構，而是一句"刪除文件"相似的破壞性語句，那麼後果實在不堪設設想。而使用eval就要擔這個風險。因此，咱們並不推薦用eval方法來進行反序列化操做(將str轉換成python中的數據結構)

2，何時使用序列化

• 數據存儲
• 網絡上傳輸的時候

3，兩種模塊

• json
• pickle
• shelve（2.x有效，3.x無效）

4

• json  # 數字 字符串 列表 字典 元組

　　　　　通用的序列化格式
　　　　   只有不多的一部分數據類型可以經過json轉化成字符串

• pickle

   　　　　 全部的python中的數據類型均可以轉化成字符串形式
    　　　　pickle序列化的內容只有python能理解
    　　　　且部分反序列化依賴python代碼

• shelve（2.x有效，3.x無效）

    　　　　序列化句柄
    　　　　使用句柄直接操做，很是方便

5，json

　　json 模塊提供了四個功能：dumps、loads、dump、load

　　5.1，json
　　　dumps序列化方法  loads反序列化方法　　直接對內存中的數據進行操做，操做後還在內存裏

dic = {"k1":'v1'}
print(type(dic),dic)
# <class 'dict'> {'k1': 'v1'}

import json
str_d = json.dumps(dic)     #序列化
print(type(str_d),str_d)
# <class 'str'> {"k1": "v1"}
#注意，json轉換完的字符串類型的字典中的字符串是由""表示的

dic_d = json.loads(str_d)   #反序列化
print(type(dic_d),dic_d)
# <class 'dict'> {'k1': 'v1'}
#注意，要用json的loads功能處理的字符串類型的字典中的字符串必須由""表示

　　

#也能夠處理嵌套的數據類型 
list_dic = [1,['a','b','c'],3,{'k1':'v1','k2':'v2'}]
str_dic = json.dumps(list_dic) 
print(type(str_dic),str_dic)
#<class 'str'> [1, ["a", "b", "c"], 3, {"k1": "v1", "k2": "v2"}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2)
#<class 'list'> [1, ['a', 'b', 'c'], 3, {'k1': 'v1', 'k2': 'v2'}]

　　5.2，json

　　　　dump    load 對文件進行操做的

import json
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)

　　5.3，在文件中寫入中文序列化

import json
dic = {1:"中國",2:'b'}
f = open('F:\臨時文件\\fff.txt','w',encoding='utf-8')
json.dump(dic,f,ensure_ascii=False)   
f.close()
# 要加入ensure_ascii=False，否則會寫入bytes類型
# 也能夠不加，不影響load的結果

f = open('F:\臨時文件\\fff.txt',encoding='utf-8')
res = json.load(f)
f.close()
print(type(res),res)

　　5.4，dump  load  不能分次往文件裏寫

# import json
# dic = {1:"中國",2:'b'}

# f = open('F:\臨時文件\\fff.txt','w',encoding='utf-8')
# json.dump(dic,f,ensure_ascii=False)
# json.dump(dic,f,ensure_ascii=False)
# f.close()

# f = open('F:\臨時文件\\fff.txt',encoding='utf-8')
# res1 = json.load(f)
# res2 = json.load(f)
# f.close()
# print(type(res1),res1)
# print(type(res2),res2)

　　5.4，dumps  loads  能夠實現：分次往文件裏寫，分次往文件外讀

# json
# dumps {} -- >爲了分次寫將其寫入成一行一行的dumps '{}\n'
# 一行一行的讀

l = [{'k':'111'},{'k2':'111'},{'k3':'111'}]
f = open('F:\臨時文件\\fff.txt','w')

import json
for dic in l:
    str_dic = json.dumps(dic)
    f.write(str_dic+'\n')
f.close()
f = open('F:\臨時文件\\fff.txt')

import json
l = []
for line in f:
    dic = json.loads(line.strip())
    l.append(dic)
f.close() 
print(l)

　　5.5，

<1> Serialize obj to a JSON formatted str.(將obj序列化爲json格式的str) 
<2> Skipkeys：默認值是False，若是dict的keys內的數據不是python的基本類型(str,unicode,int,long,float,bool,None)，設置爲False時，就會報TypeError的錯誤。此時設置成True，則會跳過這類key 
<3> ensure_ascii：當它爲True的時候，全部非ASCII碼字符顯示爲\uXXXX序列，只需在dump時將ensure_ascii設置爲False便可，此時存入json的中文便可正常顯示。
<4> If check_circular is false, then the circular reference check for container types will be skipped and a circular reference will result in an OverflowError (or worse). 
<5> If allow_nan is false, then it will be a ValueError to serialize out of range float values (nan, inf, -inf) in strict compliance of the JSON specification, instead of using the JavaScript equivalents (NaN, Infinity, -Infinity). 
<6> indent：應該是一個非負的整型，若是是0就是頂格分行顯示，若是爲空就是一行最緊湊顯示，不然會換行且按照indent的數值顯示前面的空白分行顯示，這樣打印出來的json數據也叫pretty-printed json 
<7> separators：分隔符，其實是(item_separator, dict_separator)的一個元組，默認的就是(‘,’,’:’)；這表示dictionary內keys之間用「,」隔開，而KEY和value之間用「：」隔開。 
<8> default(obj) is a function that should return a serializable version of obj or raise TypeError. The default simply raises TypeError. 
<9> sort_keys：將數據根據keys的值進行排序。 
<10> To use a custom JSONEncoder subclass (e.g. one that overrides the .default() method to serialize additional types), specify it with the cls kwarg; otherwise JSONEncoder is used.

其餘參數說明

　　5.6，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)
# 結果:
{
  "age":16,
  "sex":"male",
  "username":[
    "李華",
    "二愣子"
  ]
}

6，pickle

# 用pickle dump的序列化是bytes類型的
##
這時候機智的你又要說了，既然pickle如此強大，爲何還要學json呢？
這裏咱們要說明一下，json是一種全部的語言均可以識別的數據結構。
若是咱們將一個字典或者序列化成了一個json存在文件裏，那麼java代碼或者js代碼也能夠拿來用。
可是若是咱們用pickle進行序列化，其餘語言就不能讀懂這是什麼了～
因此，若是你序列化的內容是列表或者字典，咱們很是推薦你使用json模塊
但若是出於某種緣由你不得不序列化其餘的數據類型，而將來你還會用python對這個數據進行反序列化的話，那麼就可使用pickle

 

　　pickle模塊提供了四個功能：dumps、loads、dump、load  

　　6.1,

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

　　6.2,
　　　　(下面的程序，只有pickle能這樣寫，json不能。)
　　　　# pickle支持分次load，json不支持而是直接load
　　　　# pickle與文件打交道時，文件的模式要加b,即文件模式要是bytes數據類型的

import time
struct_time1  = time.localtime(1000000000)
struct_time2  = time.localtime(2000000000)
import pickle

f = open('Fpickle_file','wb')
pickle.dump(struct_time1,f) # dump 第一個
pickle.dump(struct_time2,f) # dump 第二個
f.close()

f = open('pickle_file','rb')
struct_time1 = pickle.load(f) # 加載dump的第一個
struct_time2 = pickle.load(f) # 加載dump的第二個
print(struct_time1.tm_year)
print(struct_time2.tm_year)
f.close()

7, shelve ( 在2.7版本有效，3.x版本無效)

　　詳情點： shelve

　　#使用時會建立三個文件

　　7.1，

　　　　路徑爲文件夾，不是文件

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)

7.2，因爲shelve在默認狀況下時不會記錄任何修改的，
     因此咱們在sheleve.open()時候須要修改默認參數writeback=True纔會保存修改。
     不然對象的修改是不會保存的。

import shelve
#修改不會保存
f1 = shelve.open('shelve_file')
print(f1['key'])
f1['key']['new_value'] = 'this was not here before'
f1.close()
#修改會保存
f2 = shelve.open('shelve_file', writeback=True)
print(f2['key'])
f2['key']['new_value'] = 'this was not here before'
f2.close()

 

8，模塊
　　　什麼是模塊？
   　　常見的場景：一個模塊就是一個包含了python定義和聲明的文件，文件名就是模塊名字加上.py的後綴。
  　　 但其實import加載的模塊分爲四個通用類別：　
　　　　1 使用python編寫的代碼（.py文件）
　　　　2 已被編譯爲共享庫或DLL的C或C++擴展
　　　　3 包好一組模塊的包
　　　　4 使用C編寫並連接到python解釋器的內置模塊

9，import
　　9.1，導入模塊
   　　1，本身寫的程序文件，能夠在另外一個程序文件中經過「import 文件名」導入。

　　　注意：第一次導入時就當即執行了被導入的程序文件，並將模塊名加載到內存中，可是重複導入只是引用，不會執行導入的文件。
   　　2，要調用被導入程序文件中的函數，要經過「模塊名.函數名」執行。

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

# 文件名：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

文件名：my_module.py

import my_modul
# 第一次導入時，執行被導入文件
# 結果：from the my_module.py

import my_module
import my_module
import my_module
# 重複導入，只第一次執行
# 結果：from the my_module.p

　　9.2，導入的過程
　　　　1，先從sys.modules裏查看是否已經被導入若是沒有被導入，就依據sys.path路徑去尋找模塊，找到了就導入
　　　　2，建立這個模塊的命名空間
　　　　3，執行文件，把文件中的名字都放到命名空間裏

import sys
print(sys.modules.keys())
print(sys.path)

　　9.3，關於導入模塊的名稱空間

　　　　每一個模塊都是一個獨立的名稱空間，定義在這個模塊中的函數，把這個模塊的名稱空間當作全局名稱空間，這樣咱們在編寫本身的模塊時，就不用擔憂咱們定義在本身模塊中全局變量會在被導入時，與使用者的全局變量衝突

 測試一:money與my_module.money不衝突

 測試二：read1與my_module.read1不衝突

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

　　總結：首次導入模塊my_module時會作三件事：

　　　　1.爲源文件(my_module模塊)建立新的名稱空間，在my_module中定義的函數和方法如果使用到了global時訪問的就是這個名稱空間。

　　　　2.在新建立的命名空間中執行模塊中包含的代碼，見初始導入import my_module

　　　　3.建立名字my_module來引用該命名空間（即不一樣的模塊是單獨的名稱空間，經過 模塊名.名稱 的方式引用）

　　9.4，給模塊起別名

import time as t   #將time模塊命名爲t
print(t.time())

　　起別名的做用：
 　　　　導入的不一樣模塊，若有相同的方法，能夠將兩個模塊命名成一樣的別名。 　　　

　　有兩中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() 

　　9.5，導入模塊要在程序文件前導入，爲了方便查看使用了什麼模塊，
 　　　　　　導入順序：內置的，擴展的，自定義的

　　　　在一行導入多個模塊

import sys,os,re

 

10，from...import...

　　10.1，導入模塊中的某個具體的方法，用

from my_module import read1,read2

10.2，不一樣於導入整個模塊，單獨導入一個模塊中的方法時，導入的方法的名字就屬於本程序文件全局變量名的範圍了，在當前名稱空間中，直接使用名字就能夠調用該導入函數。

　　所以，若是再定義一個和導入的方法同樣的變量名時，導入的就會被覆蓋。

　　但執行被導入的函數時，仍然是以被導入模塊文件爲全局名稱空間（即執行read1，read2時，使用到的變量，函數等，仍然是到my_module.py文件全局名稱空間去尋找，與本程序文件全局變量名的範圍無關）

from demo import read
def read():
    print('my read')
read()

　　10.3，可使用 from demo import * 導入全部不是如下劃線方法。

• 但要注意：當被導入模塊中，前面用語句： __all__ = ['變量名','方法名’]   則只能導入限定的這幾個變量或方法；
• 不一樣於「import 模塊」本程序不會對其有影響，而這種方法導入，便是將其變量名，方法名納入本程序全局空間中
• 大部分狀況下咱們的python程序不該該使用這種導入方式，由於*你不知道你導入什麼名字，頗有可能會覆蓋掉你以前已經定義的名字

　　10.4，支持 as

from my_module import read1 as read

　　10.5，支持多行導入

from my_module import (read1,
                  read2,
                  money)

9，__name__
  　　　　 # 在模塊中 有一個變量__name__，
 　　　　  # 當咱們直接執行這個模塊的時候，__name__ == '__main__'
  　　　　# 當咱們執行其餘模塊，在其餘模塊中引用這個模塊的時候，這個模塊中的__name__ == '模塊的名字'

if __name__ == '__main__'
   pass

　　　　#若是在本在這句話所在的程序中執行程序，該程序會執行pass
　　　　#若是該模塊被導入到其餘模塊，當等於被導入模塊名時才執行
　　　　if __name__ == '__被導入模塊名__'