python27期day16：序列化、json、pickle、hashlib、collections、軟件開發規範、做業。
序列化模塊：
什麼是序列化呢? 序列化的本質就是將一種數據結構（如字典、列表)等轉換成一個特殊的序列（字符串或者bytes）的過程就叫作序列化。
將這個字典直接寫入文件是不能夠的，必須轉化成字符串的形式，並且你讀取出來也是字符串形式的字典（能夠用代碼展現）。
json序列化除了能夠解決寫入文件的問題，還能夠解決網絡傳輸的問題，好比你將一個list數據結構經過網絡傳給另個開發者，那麼你不能夠直接傳輸，以前咱們說過，你要想傳輸出去必須用bytes類型。可是bytes類型只能與字符串類型互相轉化，它不能與其餘數據結構直接轉化，因此，你只能將list ---> 字符串 ---> bytes 而後發送，對方收到以後，在decode() 解碼成原字符串。此時這個字符串不能是咱們以前學過的str那種字符串，由於它不能反解，必需要是這個特殊的字符串，他能夠反解成list 這樣開發者之間就能夠藉助網絡互傳數據了，不只僅是開發者之間，你要藉助網絡爬取數據這些數據多半是這種特殊的字符串，你接受到以後，在反解成你須要的數據類型。
序列化模塊就是將一個常見的數據結構轉化成一個特殊的序列，而且這個特殊的序列還能夠反解回去。它的主要用途：文件讀寫數據，網絡傳輸數據。
不一樣語言都遵循的一種數據轉化格式，即不一樣語言都使用的特殊字符串。（好比Python的一個列表[1, 2, 3]利用json轉化成特殊的字符串，而後在編碼成bytes發送給php的開發者，php的開發者就能夠解碼成特殊的字符串，而後在反解成原數組(列表): [1, 2, 3]）php
json序列化只支持部分Python數據結構：dict,list, tuple,str,int, float,True,False,Nonejava
支持Python全部的數據類型包括實例化對象。python
json模塊是將知足條件的數據結構轉化成特殊的字符串，而且也能夠反序列化還原回去。linux
序列化模塊總共只有兩種用法，要不就是用於網絡傳輸的中間環節，要不就是文件存儲的中間環節，因此json模塊總共就有兩對四個方法：git
json模塊：
用於網絡傳輸：dumps、loadsgithub
用於文件寫讀：dump、loadredis
dumps、loads：算法
一、將字典類型轉換成字符串類型：數據庫
import json 編程
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = json.dumps(dic) #序列化：將一個字典轉換成一個字符串
print(type(str_dic),str_dic)
結果：<class 'str'> {"k3": "v3", "k1": "v1", "k2": "v2"} #注意，json轉換完的字符串類型的字典中的字符串是由""表示的二、將字符串類型的字典轉換成字典類型用loads：
import json
dic2 = json.loads(str_dic) #反序列化：將一個字符串格式的字典轉換成一個字典
#注意，要用json的loads功能處理的字符串類型的字典中的字符串必須由""表示
print(type(dic2),dic2)
結果：<class 'dict'> {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
三、還支持列表類型：
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'}]
dump、load：
一、將對象轉換成字符串寫入到文件當中：
import json
f = open('json_file.json','w')
dic = {'k1':'v1','k2':'v2','k3':'v3'}
json.dump(dic,f) #dump方法接收一個文件句柄，直接將字典轉換成json字符串寫入文件
f.close() # json文件也是文件，就是專門存儲json字符串的文件。
二、將文件中的字符串類型的字典轉換成字典：
import json
f = open('json_file.json')
dic2 = json.load(f) #load方法接收一個文件句柄，直接將文件中的json字符串轉換成數據結構返回
f.close()
print(type(dic2),dic2)
三、其餘參數說明：
ensure_ascii:，當它爲True的時候，全部非ASCII碼字符顯示爲\uXXXX序列，只需在dump時將ensure_ascii設置爲False便可，此時存入json的中文便可正常顯示。
separators：分隔符，其實是(item_separator, dict_separator)的一個元組，默認的就是(,,:)；這表示dictionary內keys之間用「,」隔開，而KEY和value之間用「：」隔開。
sort_keys：將數據根據keys的值進行排序。 剩下的本身看源碼研究
四、json序列化存儲多個數據到同一個文件中：
對於json序列化，存儲多個數據到一個文件中是有問題的，默認一個json文件只能存儲一個json數據，可是也能夠解決，舉例說明：
對於json 存儲多個數據到文件中：
dic1 = {'name':'oldboy1'}
dic2 = {'name':'oldboy2'}
dic3 = {'name':'oldboy3'}
f = open('序列化',encoding='utf-8',mode='a')
json.dump(dic1,f)
json.dump(dic2,f)
json.dump(dic3,f)
f.close()
f = open('序列化',encoding='utf-8')
ret = json.load(f)
ret1 = json.load(f)
ret2 = json.load(f)
print(ret)
上邊的代碼會報錯,解決方法：
dic1 = {'name':'oldboy1'} dic2 = {'name':'oldboy2'} dic3 = {'name':'oldboy3'} f = open('序列化',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('序列化',encoding='utf-8') for line in f: print(json.loads(line))
pickle模塊：
只能是Python語言遵循的一種數據轉化格式，只能在python語言中使用。
pickle模塊是將Python全部的數據結構以及對象等轉化成bytes類型，而後還能夠反序列化還原回去。
剛纔也跟你們提到了pickle模塊，pickle模塊是隻能Python語言識別的序列化模塊。若是把序列化模塊比喻成全世界公認的一種交流語言，也就是標準的話，json就是像是英語，全世界（python，java，php，C，等等）都遵循這個標準。而pickle就是中文，只有中國人（python）做爲第一交流語言。
既然只是Python語言使用，那麼它支持Python全部的數據類型包括後面咱們要講的實例化對象等，它能將這些全部的數據結構序列化成特殊的bytes，而後還能夠反序列化還原。使用上與json幾乎差很少，也是兩對四個方法。
用於網絡傳輸：dumps、loads
用於文件寫讀：dump、load
dumps、loads：
import pickle
dic = {'k1':'v1','k2':'v2','k3':'v3'}
str_dic = pickle.dumps(dic)
print(str_dic) # bytes類型
dic2 = pickle.loads(str_dic)
print(dic2) #字典
# 還能夠序列化對象
import pickle
def func():
print(666)
ret = pickle.dumps(func)
print(ret,type(ret)) # b'\x80\x03c__main__\nfunc\nq\x00.' <class 'bytes'>
f1 = pickle.loads(ret) # f1獲得 func函數的內存地址
f1() # 執行func函數
dump、load：
dic = {(1,2):'oldboy',1:True,'set':{1,2,3}}
f = open('pick序列化',mode='wb')
pickle.dump(dic,f)
f.close()
with open('pick序列化',mode='wb') as f1:
pickle.dump(dic,f1)
pickle序列化存儲多個數據到一個文件中：
dic1 = {'name':'oldboy1'}
dic2 = {'name':'oldboy2'}
dic3 = {'name':'oldboy3'}
f = open('pick多數據',mode='wb')
pickle.dump(dic1,f)
pickle.dump(dic2,f)
pickle.dump(dic3,f)
f.close()
f = open('pick多數據',mode='rb')
while True:
try:
print(pickle.load(f))
except EOFError:
break
f.close()
這時候機智的你又要說了，既然pickle如此強大，爲何還要學json呢？這裏咱們要說明一下，json是一種全部的語言均可以識別的數據結構。若是咱們將一個字典或者序列化成了一個json存在文件裏，那麼java代碼或者js代碼也能夠拿來用。可是若是咱們用pickle進行序列化，其餘語言就不能讀懂這是什麼了～因此，若是你序列化的內容是列表或者字典，咱們很是推薦你使用json模塊，但若是出於某種緣由你不得不序列化其餘的數據類型，而將來你還會用python對這個數據進行反序列化的話，那麼就可使用pickle。
shelve模塊
shelve模塊：相似於字典的操做方式去操做特殊的字符串（不講，能夠課下了解）。
#一、將字典放入文本
import shelve
f = shelve.open(r"shelve")
f["stul_info"] = {"name":"alex","age":"18"}
f.close()
# dic = {}
# dic["name"] = "alvin"
# dic["info"] = {"name":"alex"}
XML模塊
#一、用getroot打印根節點
import xml.etree.ElementTree as ET #as後面的ET代指前面模塊的名字
tree = ET.parse("xml_lesson.xml") #用ET裏面的parse方法並賦予對象tree、
root = tree.getroot()
print(root.tag)
#二、遍歷xml文檔
for i in root:
print(i)
#三、遍歷屬性tag
for i in root:
print(i.tag)
#四、雙層循環遍歷
for i in root:
for j in i:
print(j.tag)
#五、看值attrib屬性組成鍵值對
for i in root :
print(i.attrib)
#六、遍歷打印子元素
for i in root:
for j in i:
print(j.attrib)
#七、text
for i in root:
for j in i:
print(j.text)
re正則模塊
import re
#一、找到以a開頭和l結尾的
s = "hellocdalexfdsfdsfdsf"
print(s.find("alex"))
#二、371481198506143635（alex身份證號）
print(re.findall("\d+","alex22ccsd45vcxvcx767bvcbcv876"))
#三、findall(匹配規則+內容）
print(re.findall("alex","afdsvcxvfsg"))
#四、a..x(表明以a開頭中間任意兩個字符以x結尾的
print(re.findall("a..x","affxcvcvsdf"))
#五、^尖角號表明以什麼開頭
print(re.findall("^a..c","acxcxacxcx"))
#六、$表明以什麼結尾
print(re.findall("a..x$","acxvfsdfsdarrx"))
#七、*表明0到無窮次
print(re.findall("d*","dfdsfdsfdsadsadddddddddvcxvxc"))
#八、？
#九、{}爲範圍取
#十、[]中括號字符集
#十一、（小括號
print(re.findall("\([^()]*\)","12 + (34 * 6 + 2 - 5*(2-1)"))
#12\d
#13\D
#1四、|管道符表明或的意思
print(re.findall(r"ka|b","sdjkbsf"))
print(re.findall(r"ka|b","sdjkabsf"))
print(re.findall(r"ka|bc","sdjkabcsf"))
#1五、d+
print(re.sub("\d+","A","fdsfdsfjaskd4324vcxvxc"))
#1六、加參數
print(re.subn("\d","A","jackcxcvsdfd4343543543vcxvxcavcxvxd543534fdfds",8))
#1七、
loging日誌模塊
#一、日誌級別
import logging
#二、增長參數
# logging.basicConfig(
# level=logging.DEBUG,
# filename="logger.log",
# filename="w" #模式是追加
# )
# logging.debug("debug message")
# logging.info("info message")
# logging.warning("warning message")
# logging.error("error message")
# logging.critical("critical message")
#三、
import configparser
config = configparser.ConfigParser() #用configparser模塊裏面的ConfigParser類生成config對象
config["DEFAULT"] = {"ServerAliveInterval" : "45", #鍵值對
"Compression": "yes",
"CompressionLevel" : "9"}
config["bitbucket.org"] = {}
config["bitbucket.org"]["User"] = "hg"
config["topsecret.server.com"] = {}
topsecret = config["topsecret.server.com"]
topsecret["Host Port"] = "50022"
topsecret["ForwardXll"] = "no"
config["DEFAULT"]["ForwardXll"] = "yes"
with open("example.ini","w") as configfile:
config.write(configfile)
hashlib哈希模塊：
hashlib的特徵以及使用要點：
一、bytes類型數據 ---> 經過hashlib算法 ---> 固定長度的字符串
二、不一樣的bytes類型數據轉化成的結果必定不一樣。
三、相同的bytes類型數據轉化成的結果必定相同。
四、此轉化過程不可逆。
hashlib模塊就至關於一個算法的集合，這裏麪包含着不少的算法，算法越高，轉化成的結果越複雜，安全程度越高，相應的效率就會越低。
普通加密：
咱們以常見的摘要算法MD5爲例，計算出一個字符串的MD5值：
import hashlib
md5 = hashlib.md5()
md5.update('123456'.encode('utf-8')) # 必須是bytes類型纔可以進行加密
print(md5.hexdigest())
# 計算結果以下：
'e10adc3949ba59abbe56e057f20f883e'
# 驗證：相同的bytes數據轉化的結果必定相同
import hashlib
md5 = hashlib.md5()
md5.update('123456'.encode('utf-8'))
print(md5.hexdigest())
# 計算結果以下：
'e10adc3949ba59abbe56e057f20f883e'
# 驗證：不相同的bytes數據轉化的結果必定不相同
import hashlib
md5 = hashlib.md5()
md5.update('12345'.encode('utf-8'))
print(md5.hexdigest())
# 計算結果以下：
'827ccb0eea8a706c4c34a16891f84e7b'
固定加鹽：
ret = hashlib.md5('xx教育'.encode('utf-8')) # xx教育就是固定的鹽
ret.update('a'.encode('utf-8'))
print(ret.hexdigest())
結果：d9e8fff14a026ecefa7d700334279762
動態加鹽：
username = '寶元666'
ret = hashlib.md5(username[::2].encode('utf-8')) # 針對於每一個帳戶，每一個帳戶的鹽都不同
ret.update('a'.encode('utf-8'))
print(ret.hexdigest())
sha系列：sha1,sha224,sha512等等，數字越大，加密的方法越複雜，安全性越高，可是效率就會越慢。
ret = hashlib.sha1()
ret.update('guobaoyuan'.encode('utf-8'))
print(ret.hexdigest())
#也可加鹽
ret = hashlib.sha384(b'asfdsa')
ret.update('guobaoyuan'.encode('utf-8'))
print(ret.hexdigest())
# 也能夠加動態的鹽
ret = hashlib.sha384(b'asfdsa'[::2])
ret.update('guobaoyuan'.encode('utf-8'))
print(ret.hexdigest())
文件的一致性校驗：
hashlib模塊除了能夠用於密碼加密以外，還有一個經常使用的功能，那就是文件的一致性校驗。linux講究：一切皆文件，咱們普通的文件，是文件，視頻，音頻，圖片，以及應用程序等都是文件。咱們都從網上下載過資源，好比咱們剛開學時讓你們從網上下載Python解釋器，當時你可能沒有注意過，其實你下載的時候都是帶一個MD5或者shax值的，爲何？ 咱們的網絡世界是很不安全的，常常會遇到病毒，木馬等，有些你是看不到的可能就植入了你的電腦中，那麼他們是怎麼來的？ 都是經過網絡傳入來的，就是你在網上下載一些資源的時候，趁虛而入，固然大部分被咱們的瀏覽器或者殺毒軟件攔截了，可是還有一部分偷偷的進入你的磁盤中了。那麼咱們本身如何驗證咱們下載的資源是否有病毒呢？這就須要文件的一致性校驗了。在咱們下載一個軟件時，每每都帶有一個MD5或者shax值，當咱們下載完成這個應用程序時你要是對比大小根本看不出什麼問題，你應該對比他們的md5值，若是兩個md5值相同，就證實這個應用程序是安全的，若是你下載的這個文件的MD5值與服務端給你提供的不一樣，那麼就證實你這個應用程序確定是植入病毒了（文件損壞的概率很低），那麼你就應該趕忙刪除，不該該安裝此應用程序。
咱們以前說過，md5計算的就是bytes類型的數據的轉換值，同一個bytes數據用一樣的加密方式轉化成的結果必定相同，若是不一樣的bytes數據（即便一個數據只是刪除了一個空格）那麼用一樣的加密方式轉化成的結果必定是不一樣的。因此，hashlib也是驗證文件一致性的重要工具。
校驗Pyhton解釋器的Md5值是否相同：
import hashlib
def file_check(file_path):
with open(file_path,mode='rb') as f1:
sha256 = hashlib.md5()
while 1:
content = f1.read(1024)
if content:
sha256.update(content)
else:
return sha256.hexdigest()
print(file_check('python-3.6.6-amd64.exe'))
socketserver模塊：
server類：處理連接包含：BaseServer、TcpServer、UdpServer、UnixStreamServer、UnixDatagramServer。
request類：處理通訊包含BaseRequestHandler、StreamRequestHandler、DatagramRequestHandler。
對於tcp來講
self.request=conn
對於udp來講
self.request=(client_data_bytes,udp的套接字對象)
collections（收藏）模塊：
在內置數據類型（dict、list、set、tuple）的基礎上，collections模塊還提供了幾個額外的數據類型：Counter、deque、defaultdict、namedtuple和OrderedDict以及判斷什麼是可迭代對象什麼是迭代器
1.namedtuple: 生成可使用名字來訪問元素內容的tuple
2.deque: 雙端隊列，能夠快速的從另一側追加和推出對象
3.Counter: 計數器，主要用來計數
4.OrderedDict: 有序字典
5.defaultdict: 帶有默認值的字典
namedtuple：
咱們知道tuple能夠表示不變數據，例如，一個點的二維座標就能夠表示成：
可是，看到(1, 2)，很難看出這個tuple是用來表示一個座標的。
這時，namedtuple就派上了用場：p = (1, 2)
from collections import namedtuple
point = namedtuple("point",["x","y"])
p = point(1,2)
print(p)
結果：point(x=1, y=2)
deque：
使用list存儲數據時，按索引訪問元素很快，可是插入和刪除元素就很慢了，由於list是線性存儲，數據量大的時候，插入和刪除效率很低。
deque是爲了高效實現插入和刪除操做的雙向列表，適合用於隊列和棧：
from collections import deque
q = deque(['a', 'b', 'c'])
q.append('x')
q.appendleft('y')
print(q)
結果：q deque(['y', 'a', 'b', 'c', 'x'])
deque除了實現list的append()和pop()外，還支持appendleft()和popleft()，這樣就能夠很是高效地往頭部添加或刪除元素。
OrderedDict：
使用dict時，Key是無序的。在對dict作迭代時，咱們沒法肯定Key的順序。
若是要保持Key的順序，能夠用OrderedDict：
from collections import OrderedDict
od = OrderedDict([("a",1),("b",2),("c",3)])
print(od)
結果：OrderedDict([('a', 1), ('b', 2), ('c', 3)])
OrderedDict的Key會按照插入的順序排列，不是Key自己排序：
from collections import OrderedDict
od = OrderedDict([("a",1),("b",2),("c",3)])
od["z"] = 1
od["y"] = 2
od["x"] = 3
print(od.keys())
結果：odict_keys(['a', 'b', 'c', 'z', 'y', 'x'])
defaultdict：
有以下值集合 [11,22,33,44,55,66,77,88,99,90...]，將全部大於 66 的值保存至字典的第一個key中，將小於 66 的值保存至第二個key的值中。
即： {'k1': 大於66 , 'k2': 小於66}
from collections import defaultdict
values = [11,22,33,44,55,66,77,88,99,90]
my_dict = defaultdict(list)
for value in values:
if value > 66:
my_dict["k1"].append(value)
else:
my_dict["k2"].append(value)
print(my_dict)
結果：defaultdict(<class 'list'>, {'k2': [11, 22, 33, 44, 55, 66], 'k1': [77, 88, 99, 90]})
Counter：
Counter類的目的是用來跟蹤值出現的次數。它是一個無序的容器類型，以字典的鍵值對形式存儲，其中元素做爲key，其計數做爲value。計數值能夠是任意的Interger（包括0和負數）。Counter類和其餘語言的bags或multisets很類似。
from collections import Counter
c = Counter("dsadasdsfdafsdsfds")
print(c)
結果：Counter({'d': 6, 's': 6, 'a': 3, 'f': 3})
isinstance：
判斷當前數據類型,返回的是一個布爾值
from collections import Iterable,Iterator lst = [1,2,3,4] print(isinstance(lst,list)) # 判斷lst是否是列表類型 返回的是True print(isinstance(lst,Iterator)) # 判斷lst是否是迭代器 返回的是False print(isinstance(lst,Iterable)) # 判斷lst是否是可迭代對象 返回的是True
軟件開發規範：
你如今包括以前寫的一些程序，所謂的'項目'，都是在一個py文件下完成的，代碼量撐死也就幾百行，你認爲沒問題，挺好。可是真正的後端開發的項目，系統等，少則幾萬行代碼，多則十幾萬，幾十萬行代碼，你全都放在一個py文件中行麼？固然你能夠說，只要能實現功能便可。我們舉個例子，若是你的衣物只有三四件，那麼你隨便堆在櫥櫃裏，沒問題，咋都能找到，也不顯得特別亂，可是若是你的衣物，有三四十件的時候，你在都堆在櫥櫃裏，可想而知，你找你穿過三天的襪子，最終從你的大衣口袋裏翻出來了，這是什麼感受和心情......
軟件開發，規範你的項目目錄結構，代碼規範，遵循PEP8規範等等，讓你更加清晰滴，合理滴開發。
那麼接下來咱們以博客園系統的做業舉例，將咱們以前在一個py文件中的全部代碼，整合成規範的開發。
首先咱們看一下，這個是咱們以前的目錄結構（簡化版）：
py文件的具體代碼以下：
status_dic = { 'username': None, 'status': False, } flag = True def login(): i = 0 with open('register', encoding='utf-8') as f1: dic = {i.strip().split('|')[0]: i.strip().split('|')[1] for i in f1} while i < 3: username = input('請輸入用戶名：').strip() password = input('請輸入密碼：').strip() if username in dic and dic[username] == password: print('登陸成功') return True else: print('用戶名密碼錯誤，請從新登陸') i += 1 def register(): with open('register', encoding='utf-8') as f1: dic = {i.strip().split('|')[0]: i.strip().split('|')[1] for i in f1} while 1: print('\033[1;45m 歡迎來到註冊頁面 \033[0m') username = input('請輸入用戶名：').strip() if not username.isalnum(): print('\033[1;31;0m 用戶名有非法字符，請從新輸入 \033[0m') continue if username in dic: print('\033[1;31;0m 用戶名已經存在，請從新輸入 \033[0m') continue password = input('請輸入密碼：').strip() if 6 <= len(password) <= 14: with open('register', encoding='utf-8', mode='a') as f1: f1.write(f'\n{username}|{password}') status_dic['username'] = str(username) status_dic['status'] = True print('\033[1;32;0m 恭喜您，註冊成功！已幫您成功登陸~ \033[0m') return True else: print('\033[1;31;0m 密碼長度超出範圍，請從新輸入 \033[0m') def auth(func): def inner(*args