序列化模組

首先我們來看一個序列：'sdfs45sfsgerg4454287789sfsf&*0'

序列 —— 就是字串
序列化 —— 從資料型別 --> 字串的過程
反序列化 —— 從字串 --> 資料型別的過程

首先要了解到的是：一般沒事不會把一個其他資料型別轉化為字串，因為這樣功能就變少了，如：字典，列表...

序列化模組
json *****（非常重要）
pickle ****
shelve ***

json
　　數字 字串 列表 字典 元組
　　通用的序列化格式（語言界的英語）
　　只有很少的一部分資料型別能夠通過 json 轉化成字串
pickle
　　所有的 python 中的資料型別都可以轉化成字串形式
　　pickle 序列化的內容只有 python 能理解
　　且部分反序列化依賴 python 程式碼
　　比如：用於遊戲中
shelve
　　序列化控制代碼（shelve 控制代碼）
　　使用控制代碼直接操作，非常方便

json 序列化

json   （dumps  loads）
　　dumps（序列化方法）、loads（反序列化方法），這兩個直接對記憶體中的資料進行操作
　　json 本身是單引號的，內部原本是字串元素要用雙引號

json.dumps

import json
data = {'username':['李華','二愣子'],'sex':'male','age':16}
json_dic2 = json.dumps(data,sort_keys=True,indent=4,separators=(',',':'),ensure_ascii=False)
 
print(json_dic2)

sort_keys=True 　　 排序
indent 　　　　　　  整齊列印，填充物為空格
separators=()  　　   緊湊編碼
ensure_ascii=False   輸出為中文，（中文顯示預設為 ascii 碼）

dic = {"k":'v'}
print(type(dic),dic)     #輸出結果：<class 'dict'> {'k': 'v'}
str_d = json.dumps(dic)   #序列化
print(type(str_d),str_d)  #輸出結果：<class 'str'> {"k": "v"}
 

json.loads

#接上面的例子中 str_d
dic_d = json.loads(str_d) #反序列化
print(type(dic_d),dic_d)  #輸出結果：<class 'dict'> {'k': 'v'}

元組也可以序列化（但被當做列表處理了）

dic = (1,2,3)
print(type(dic),dic)

str_d = json.dumps(dic)
print(type(str_d),str_d)

dic_d = json.loads(str_d)
print(type(dic_d),dic_d)

#輸出結果如下
#<class 'tuple'> (1, 2, 3)
#<class 'str'> [1, 2, 3]
#<class 'list'> [1, 2, 3]

dump（序列換方法）、load（範序列化方法），這兩個是對檔案相關的操作
dump load 一次性寫入 一次性讀出

import json
dic = {1:"a",2:"b"}

f = open('D:/py/file.txt','w',encoding='utf-8')
ret = json.dump(dic,f)
f.close()
print(type(ret),ret)    #輸出結果：<class 'NoneType'> None

f = open('D:/py/file.txt',encoding='utf-8')
res = json.load(f)
f.close()
print(type(res),res)    #輸出結果：<class 'dict'> {'2': 'b', '1': 'a'}

with open('D:/py/file.txt','w',encoding='utf-8')as f:
    ret = json.dump(dic,f)
    print(type(ret),ret) 

with open('D:/py/file.txt',encoding='utf-8')as f:
    res = json.load(f)
    print(type(res),res)

#檔案中的結果：{"1": "a", "2": "b"}

改寫為中文字元：ensure_ascii=False

import json
dic = {1:"雷諾",2:"諾娃"}

with open('D:/py/file.txt','w',encoding='utf-8')as f:
    ##ret = json.dump(dic,f)
    ret = json.dump(dic,f,separators=(',',':'),ensure_ascii=False)
    print(type(ret),ret)    #輸出結果：<class 'NoneType'> None

with open('D:/py/file.txt',encoding='utf-8')as f:
    res = json.load(f)
    print(type(res),res)    #輸出結果：<class 'dict'> {'1': '雷諾', '2': '諾娃'}

##檔案中的結果：{"1": "\u96f7\u8bfa", "2": "\u8bfa\u5a03"}
#檔案中的結果：{"1":"雷諾","2":"諾娃"}

模組的匯入

模組匯入的流程
　　先從sys.modules裡檢視是否已經被匯入，即：模組不會被重複匯入
　　如果沒有被匯入，就依據sys.path路徑取尋找模組
　　找到了就匯入
　　建立這個模組的名稱空間
　　執行檔案，把檔案中的名字都放到名稱空間裡
　　import sys
　　print(sys.modules.keys())
　　print(sys.path)

匯入 demo 及其中的函式

import demo
demo.reads()
#輸出結果：還是這個模組

函式的別名

設定別名後，只有別名可以用，原來的函式名已經是過去式了

import time as t
print(t.time())
print(time.time())  #NameError: name 'time' is not defined

模組的集體呼叫

#模組的匯入要寫在檔案的最開始匯入
#先匯入內建模組——再匯入擴充套件模組——之後是自定義的（這樣分為三行寫）
import time，sys，os  #不推薦這樣寫 不利於可讀性和加大的修改成本
import time
import sys
import os

from ... import ...

當使用改種方法時，times 函式就變為了全域性函式
如果在自己的檔案中在 建立一個 times()，則 demo 中的 times 會被覆蓋掉
使用改種的優點是節省記憶體，只把自己需要的函式名拿過來，直接使用 import 是把被呼叫的檔案中的函式名都拿來了

from demo import times
print(times())

from demo import times,reads  #使用逗號隔開 呼叫多個
from demo import *  #相當於呼叫 demo 中的所有（不安全，儘量不要用）

第四種
form demo import * 與 __all__ = [''] 的關聯使用

#當使用這種模式呼叫模組時： form demo import * 與 __all__ = ['']
#此時就只能呼叫 __all__ 對應列表中的函式
from demo import *  #__all__ = ['times']
print(times())
reads()  #報錯  NameError: name 'reads' is not defined

小結：

所有的模組匯入都應該儘量往上寫（順序如下）
　　內建模組
　　擴充套件模組
　　自定義模組
模組不會重複被匯入 ： sys.moudles
從哪兒匯入模組 : sys.path

import
　　import 模組名
　　模組名.變數名 和本檔案中的變數名完全不衝突
　　import 模組名 as 重新命名的模組名 ： 提高程式碼的相容性
　　import 模組1，模組2（不推薦使用）

from ... import ...
　　from 模組名 import 變數名
　　直接使用 變數名 就可以完成操作
　　如果本檔案中有相同的變數名會發生衝突

from 模組名 import 變數名字 as 重新命名變數名
　　from 模組名 import 變數名1，變數名2
　　from 模組名 import *
　　將模組中的所有變數名都放到記憶體中
　　如果本檔案中有相同的變數名會發生衝突

from 模組名 import * 和 __all__ 是一對
　　沒有這個變數，就會匯入所有的名字
　　如果有 all 只匯入 all 列表中的名字

__name__
　　在模組中 有一個變數 __name__
　　當我們直接執行這個模組的時候，__name__ == '__main__'
　　當我們執行其他模組，在其他模組中引用這個模組的時候，這個模組中的__name__ == '模組的名字'