模塊：

　　py文件就是模塊。

　　python之所以好用，因為模塊多。

　　內置模塊：python安裝的時候自帶的。

　　擴展模塊：別人寫好的，需要安裝後可直接使用。

　　自定義模塊：自己寫的模塊。

序列化模塊：

　　　　能存儲在文件中的一定是字符串或者字節，能在網絡上傳輸的只有字節。

　　　　序列化：就是創造一個序列（字符串）。

python中的序列化模塊：

　　　　json：所有的編程語言都通用的序列格式。

　　　　　　　　它支持的數據類型非常有限，數字，字符串，列表，字典。

　　　　pickle：只能在python語言的程序之間傳遞數據用的。

　　　　　　　　pickle支持python中的所有數據類型。

　　　　shelve：python3x之後才有的。

json模塊：識別不了元祖類型，會將元組類型直接轉換成列表類型。

　　dumps：序列化，loads：反序列化

import json
dic = {‘顧清秋‘:(175,70,‘Music‘)}
ret = json.dumps(dic,ensure_ascii=False)    # dump 將字典序列化
print(ret,type(ret))        # {"顧清秋": [175, 70, "Music"]} <class ‘str‘>
res = json.loads(ret)       # loads  反序列化
 

print(res,type(res))        # {‘顧清秋‘: [175, 70, ‘Music‘]} <class ‘dict‘>

　　dump 和 load 是直接將對象序列化後寫入文件。依賴一個文件句柄。

import json
dic = {‘顧清秋‘:(175,70,‘Music‘)}
f = open(‘log‘,encoding=‘utf-8‘,mode=‘w‘)   # 打開一個文件以‘w’模式
json.dump(dic,f,ensure_ascii=False) # 先接受序列化對象，在接受文件句柄
f.close()
f = open(‘log‘
 
,encoding=‘utf-8‘)    # 以‘r‘模式打開一個文件
content = json.load(f)
print(content)  # {‘顧清秋‘: [175, 70, ‘Music‘]}

　　寫入多個字典時：

import json
dic1 = {‘顧清秋‘:(175,70,‘Music‘)}
dic2 = {‘顧小白‘:(175,70,‘Music‘)}
dic3 = {‘懶笨呆‘:(175,70,‘Music‘)}
f = open(‘log2‘,encoding=‘utf-8‘,mode=‘a‘)
#  先序列化，再逐個寫入文件
str1 = json.dumps(dic1)     
f.write(str1+‘\n‘)
str2 = json.dumps(dic2)
f.write(str2+‘\n‘)
str3 = json.dumps(dic3)
f.write(str3+‘\n‘)
f.close()
f = open(‘log2‘,encoding=‘utf-8‘)
# 用for循環讀取
for line in f:
    print(json.loads(line.strip()))     # 用loads(反序列化) 打印出原類型
f.close()
# {‘顧清秋‘: [175, 70, ‘Music‘]}
# {‘顧小白‘: [175, 70, ‘Music‘]}
# {‘懶笨呆‘: [175, 70, ‘Music‘]}

dumps 序列化，loads 反序列化：之在內存中操作數據，主要用於網絡傳輸。

dump 序列化，load 反序列化：主要用於一個數據直接存在文件裏--直接和文件打交道。

json不支持元組 不支持除了str數據類型之外的key：

import json
dic = {(175,70,‘Music‘):‘顧清秋‘}  # 以元祖為鍵，json不支持元祖。
ret = json.dumps(dic)
print(ret)
# TypeError: keys must be a string

pickle模塊：可識別元祖。

　　dumps : 序列化後是一個bytes類型。

　　loads：反序列化轉回原類型。

import pickle
dic = {‘顧清秋‘: (175, 70, ‘Music‘)}
ret = pickle.dumps(dic)     # 序列化結果：不是一個可讀的字符串，而是一個bytes類型。
print(ret)
res = pickle.loads(ret)
print(res)  # {‘顧清秋‘: (175, 70, ‘Music‘)}

　　dump 和 load：

import pickle
dic = {‘顧清秋‘: (175, 70, ‘Music‘)}
f =  open(‘log2‘,‘wb‘)  #  以wb模式就無需編碼(不用寫encoding=‘utf-8‘)
pickle.dump(dic,f)      # 序列化成bytes類型寫入文件
f.close()
f = open(‘log2‘,‘rb‘)   # 讀取是以rb模式。
content = pickle.load(f) 
print(content)      # {‘顧清秋‘: (175, 70, ‘Music‘)}
f.close()

　　寫入多行：

import pickle
dic1 = {‘顧清秋‘:(175,70,‘Music‘)}
dic2 = {‘顧小白‘:(175,70,‘Music‘)}
dic3 = {‘懶笨呆‘:(175,70,‘Music‘)}
f = open(‘log‘,‘wb‘)
pickle.dump(dic1,f)
pickle.dump(dic2,f)
pickle.dump(dic3,f)
f.close()
f = open(‘log‘,‘rb‘)
while True:
    try:
        print(pickle.load(f))
    except:
        break
# {‘顧清秋‘: (175, 70, ‘Music‘)}
# {‘顧小白‘: (175, 70, ‘Music‘)}
# {‘懶笨呆‘: (175, 70, ‘Music‘)}

關於序列化自定義類的對象：

import pickle
class A:
    def __init__(self,name,age):
        self.name = name
        self.age = age
a = A(‘顧清秋‘,17)
f =  open(‘顧清秋‘,‘wb‘)
pickle.dump(a,f)
f.close()
f = open(‘顧清秋‘,‘rb‘)
content = pickle.load(f)
print(content)  # <__main__.A object at 0x000001D0FE619828>
print(content.__dict__)     # {‘name‘: ‘顧清秋‘, ‘age‘: 17}
f.close()

模塊 shelve：

　　python 專有的序列化模塊，只針對文件。

import shelve
f = shelve.open(‘shelve_file‘)   # 打開文件
f[‘key‘] = {‘int‘: 10,‘float‘:9.5,‘strig‘:‘Sample data‘} # 直接對文件句柄操作，就可以存入數據。
f.close()
f1 = shelve.open(‘shelve_file‘)
existing = f1[‘key‘] # 取數據的時候也只需要直接用key獲取即可，但如果key不存在會報錯。
f1.close()
print(existing)

　　設置只讀方式：flag = ‘r’

import shelve
f = shelve.open(‘shelve_file‘,flag = ‘r‘)
existing = f[‘key‘]
# f[‘key‘][‘int‘] = 50    # 不能修改已有結構中的值
# f[‘key‘][‘new‘] = ‘new‘ # 不能再已有的結構中添加新的項。
f[‘key‘] = ‘new‘    # 但是可以覆蓋原來的結構
f.close()
print(existing)

　　寫入：writeback = True

import shelve
f = shelve.open(‘shelve_file‘,writeback = True)
f[‘key‘] = {‘name‘:‘顧小白‘,‘age‘:17}
f[‘key‘][‘hobby‘] = ‘Music‘
f.close()
f = shelve.open(‘shelve_file‘,flag=‘r‘)
content1 = f[‘key‘]
print(content1)     #  {‘hobby‘: ‘Music‘, ‘name‘: ‘顧小白‘, ‘age‘: 17}
f.close()

hashlib——摘要算法：

　　也是算法的集合，有好多算法。

　　字符串——> 數字

　　不同的字符串--->數字一定不同。

　　無論在哪臺機器上，在什麽時候計算，對相同的字符串，結果總是一樣的。

　　摘要的過程不可逆。

　　用法：

　　　　1，文件的一致性校驗。2，密文驗證的時候加密。

　　密文驗證的時候加密：

　　md5算法：通用的算法。

　　sha算法：安全系數更高，sha算法有很多種，後面的數字越大，安全系數越高，

　　　　　　　　得到的數字結果越長，計算的時間越長。

import hashlib
m = hashlib.md5()
m.update(‘alex3714‘.encode(‘utf-8‘))
print(m.hexdigest())        # aee949757a2e698417463d47acac93df    # 16進制的數字

　　為了防止暴力破解和撞庫：

　　　　加鹽：　　

import hashlib
# m = hashlib.md5()
m = hashlib.md5(‘guxiaobai‘.encode(‘utf-8‘))
m.update(‘123456‘.encode(‘utf-8‘))
print(m.hexdigest())    # b25cc83ffee9268a80c0c32e107d1ad5

　　　　動態加鹽：

import hashlib
username = input(‘>>>‘)
password = input(‘*>>>‘)
m = hashlib.md5(username.encode(‘utf-8‘))
m.update(password.encode(‘utf-8‘))
print(m.hexdigest())

python's twenty-fifth day for me 模塊