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