常用模块 (二)

?. 什么是序列化
    在我们存储数据或者?络传输数据的时候. 需要对我们的对象进?处理. 把对象处理成
?便存储和传输的数据格式. 这个过程叫序列化. 不同的序列化, 结果也不同. 但是?的是?
样的. 都是为了存储和传输.
    在python中存在三种序列化的?案.
　　1. pickle. 可以将我们python中的任意数据类型转化成bytes并写入到?件中. 同样也
可以把?件中写好的bytes转换回我们python的数据. 这个过程被称为反序列化
　　2. shelve. 简单另类的?种序列化的?案. 有点?类似后?我们学到的redis. 可以作为
?种?型的数据库来使?
　　3. json. 将python中常?的字典, 列表转化成字符串. 是?前前后端数据交互使?频率
最?的?种数据格式.

?. pickle(重点)
　pickle?起来很简单. 说?了. 就是把我们的python对象写入到?件中的?种解决?案.
但是写入到?件的是bytes. 所以这东?不是给?看的. 是给机器看的.

import pickle
class Cat:
 def __init__(self, name, age):
 self.name = name
 self.age = age
 def catchMouse(self):
 print(self.name, "抓??")
c = Cat("jerry", 18)
bs = pickle.dumps(c) # 序列化?个对象.
print(bs) # ?堆?进制. 看不懂
cc = pickle.loads(bs) # 把?进制反序列化成我们的对象
cc.catchMouse() # 猫依然是猫. 还可以抓??

　　pickle中的dumps可以序列化?个对象. loads可以反序列化?个对象. 我们使?dump
还可以直接 把?个对象写入到?件中

# f = open("cat", mode="wb")
# pickle.dump(c, f) # 写?到?件中
# f.close()
f = open("cat", mode="rb")
cc = pickle.load(f) # 从?件中读取对象
cc.catchMouse()

　　pickle还?持多个对象的写出.

lst = [Cat("jerry", 19), Cat("tommy", 20), Cat("alpha", 21)]
f = open("cat", mode="wb")
for el in lst:
 pickle.dump(el, f) # 写?到?件中
f.close()
f = open("cat", mode="rb")
for i in range(len(lst)):
 cc = pickle.load(f) # 从?件中读取对象
 cc.catchMouse()

但是这样写并不够好. 因为读的时候. 并不能知道有多少对象要读. 这?记住, 不能??
??的读. 那真的要写入或者读取多个内容怎么办? 很简单. 装list?. 然后读取和写入都?
list

　　记住?点, pickle序列化的内容是?进制的内容(bytes) 不是给?看的.

三. shelve
　　shelve提供python的持久化操作. 什么叫持久化操作呢? 说?话,就是把数据写到硬盘上.
在操作shelve的时候非常的像操作?个字典. 这个东?到后期. 就像redis差不多.

import shelve
shelf = shelve.open("sylar")
# shelf["jay"] = "周杰伦"
print(shelf[‘jay‘])
shelf.close()

感觉到了么. 这个?东?和字典差不多. 只不过你的字典是?个?件. 接下来, 我们存储
?些复杂的数据

s = shelve.open("sylar")
# s["jay"] = {"name":"周杰伦", "age":18, "hobby":"哄?孩"}
print(s[‘jay‘])
s.close()

但是, 有坑

s = shelve.open("sylar")
s[‘jay‘][‘name‘] = "胡辣汤" # 尝试改变字典中的数据
s.close()
s = shelve.open("sylar")
print(s[‘jay‘]) # 并没有改变
s.close()

解决?案

s = shelve.open("sylar", writeback=True)
s[‘jay‘][‘name‘] = "胡辣汤" # 尝试改变字典中的数据
s.close()
s = shelve.open("sylar")
print(s[‘jay‘]) # 改变了.
s.close()

　　writeback=True可以动态的把我们修改的信息写入到?件中. ?且这个?东?还可以删
除数据. 就像字典?样. 上?波操作

s = shelve.open("sylar", writeback=True)
del s[‘jay‘]
s.close()
s = shelve.open("sylar")
print(s[‘jay‘]) # 报错了, 没有了
s.close()
s = shelve.open("sylar", writeback=True)
s[‘jay‘] = "周杰伦"
s[‘wlj‘] = "王?宏"
s.close()
s = shelve.open("sylar")
for k in s: # 像字典?样遍历
 print(k)
print(s.keys()) # 拿到所有key的集合
for k in s.keys():
 print(k)

for k, v in s.items(): # 像字典?样操作
print(k, v)
s.close()

　　综上shelve就当成字典来?就?了. 它比redis还简单.......

四. json(重点)
　　终于到json了. json是我们前后端交互的枢纽. 相当于编程界的普通话. ?家沟通都?
json. 为什么这样呢? 因为json的语法格式可以完美的表?出?个对象. 那什么是json: json全
称javascript object notation. 翻译过来叫js对象简谱. 很复杂是吧? 来上?段我们认识的代
码:

wf = {
 "name":"汪峰",
 "age":18,
 "hobby":"上头条",
 "wife":{
 "name":‘?怡‘,
 "age":19,
 "hobby":["唱歌", "跳舞", "演戏"]
 }
}

　　这个不是字典么? 对的. 在python?这玩意叫字典. 但是在javascript?这东?叫json. ?
模?样的. 我们发现?这样的数据结构可以完美的表?出任何对象. 并且可以完整的把对象
表?出来. 只要代码格式比较好. 那可读性也是很强的. 所以?家公认?这样?种数据结构作
为数据交互的格式. 那在这个?东?之前是什么呢? XML.....来看?段代码

<?xml version="1.0" encoding="utf-8" ?>
<wf>
 <name>汪峰</name>
 <age>18</age>
 <hobby>上头条</hobby>
 <wife>
 <name>?怡</name>
 <age>18</age>
 <hobbies>
 <hobby>唱歌</hobby>
 <hobby>跳舞</hobby>
 <hobby>演戏</hobby>
 </hobbies>
 </wife>

</wf>

　　古?(老程序员)都是?这样的数据进?传输的. 先不管这个东?好不好看. 这玩意想要解
析.. 那简直了. 想死的?都有. 所以老版本的xml在维护和处理上是非常复杂和繁琐的. 多说
?嘴, 就是因为这个?东?太难解析. 以前的项??乎没有?ajax的.

　　OK. 那json既然这么?B好?. 怎么?呢? 注意. 这??出来?个新问题. 我们的程序是
在python?写的. 但是前端是在JS那边来解析json的. 所以. 我们需要把我们程序产?的字典
转化成json格式的json串(字符串). 然后?络传输. 那边接收到了之后. 它爱怎么处理是它的事
情. 那, 如何把字典转化成我们的json格式的字符串呢?很简单, 上代码.

import json
dic = {"a": "?王", "b": "萝莉", "c": "?清新"}
s = json.dumps(dic) # 把字典转化成json字符串
print(s) # {"a": "\u5973\u738b", "b": "\u841d\u8389", "c":
"\u5c0f\u6e05\u65b0"}
 

　　结果很不友好啊. 那如何处理中?呢? 在dumps的时候给出另?个参数
ensure_ascii=False就可以了

import json
dic = {"a": "?王", "b": "萝莉", "c": "?清新"}
s = json.dumps(dic, ensure_ascii=False) # 把字典转化成json字符串
print(s) # {"a": "?王", "b": "萝莉", "c": "?清新"}

　　搞定了. 接下来. 前端给你传递信息了. 你要把前端传递过来的json字符串转化成字典.

import json
s = ‘{"a": "?王", "b": "萝莉", "c": "?清新"}‘
dic = json.loads(s)
print(type(dic), dic)

　　搞定. 是不是很简单. 以上两个代码要求. 记住, 理解, 背会

　　json也可以像pickle?样把序列化的结果写入到?件中.

dic = {"a": "?王", "b": "萝莉", "c": "?清新"}
f = open("test.json", mode="w", encoding="utf-8")
json.dump(dic, f, ensure_ascii=False) # 把对象打散成json写?到?件中
f.close()

　　同样也可以从?件中读取?个json

f = open("test.json", mode="r", encoding="utf-8")
dic = json.load(f)
f.close()
print(dic)

　　注意. 我们可以向同?个?件中写?多个json串. 但是读不?.

import json
lst = [{"a": 1}, {"b": 2}, {"c": 3}]
f = open("test.json", mode="w", encoding="utf-8")
for el in lst:
 json.dump(el, f)
f.close()

注意, 此时?件中的内容是??内容.

{‘a‘:1}{‘b‘:2}{‘c‘:3}

这在读取的时候是?法正常读取的. 那如何解决呢? 两套?案. ?案?. 把所有的内容准备好统?
进?写?和读取. 但这样处理, 如果数据量?还好. 数据量?的话, 就不够友好了. ?案?. 不?
dump. 改?dumps和loads. 对每??分别进?处理.

import json
lst = [{"a": 1}, {"b": 2}, {"c": 3}]
# 写?
f = open("test.json", mode="w", encoding="utf-8")
for el in lst:
 s = json.dumps(el, ensure_ascii=True) + "\n"
 f.write(s)
f.close()
# 读取
f = open("test.json", mode="r", encoding="utf-8")
for line in f:
 dic = json.loads(line.strip())
 print(dic)
f.close()

五. configparser模块
　　该模块适?于配置?件的格式与windows ini?件类似，可以包含?个或多个节(section)每个节
可以有多个参数(键=值). ?先, 我们先看?个xxx服务器的配置?件

[DEFAULT] [DEFAULT]
ServerAliveInterval = 45
Compression = yes
CompressionLevel = 9
ForwardX11 = yes
[[bitbucket.org bitbucket.org]]
User = hg
[[topsecret.server.com topsecret.server.com]]
Port = 50022
ForwardX11 = no

　　我们?configparser就可以对这样的?件进?处理.?先, 是初始化

import configparser
config = configparser.ConfigParser()
config[‘DEFAULT‘] = {
 "sleep": 1000,
 "session-time-out": 30,
 "user-alive": 999999
}
config[‘TEST-DB‘] = {
 "db_ip": "192.168.17.189",
 "port": "3306",
 "u_name": "root",
 "u_pwd": "123456"
}
config[‘168-DB‘] = {
 "db_ip": "152.163.18.168",
 "port": "3306",
 "u_name": "root",
 "u_pwd": "123456"
}
config[‘173-DB‘] = {
 "db_ip": "152.163.18.173",
 "port": "3306",
 "u_name": "root",
 "u_pwd": "123456"
}
f = open("db.ini", mode="w")
config.write(f) # 写??件
f.flush()
f.close()

　　读取?件信息:

config = configparser.ConfigParser()
config.read("db.ini") # 读取?件
print(config.sections()) # 获取到section. 章节...DEFAULT是给每个章节都配备的信息
print(config.get("DEFAULT", "SESSION-TIME-OUT")) # 从xxx章节中读取到xxx信息
# 也可以像字典?样操作
print(config["TEST-DB"][‘DB_IP‘])
print(config["173-DB"]["db_ip"])
for k in config[‘168-DB‘]:
 print(k)
for k, v in config["168-DB"].items():
 print(k, v)
print(config.options(‘168-DB‘)) # 同for循环,找到‘168-DB‘下所有键
print(config.items(‘168-DB‘)) #找到‘168-DB‘下所有键值对
print(config.get(‘168-DB‘,‘db_ip‘)) # 152.163.18.168 get?法Section下的
key对应的value

　　增删改操作:

# 先读取. 然后修改. 最后写回?件
config = configparser.ConfigParser()
config.read("db.ini") # 读取?件
# 添加?个章节
# config.add_section("189-DB")
# config["189-DB"] = {
# "db_ip": "167.76.22.189",
# "port": "3306",
# "u_name": "root",
# "u_pwd": "123456"
# }
# 修改信息
config.set("168-DB", "db_ip", "10.10.10.168")
# 删除章节
config.remove_section("173-DB")
# 删除元素信息
config.remove_option("168-DB", "u_name")
# 写回?件
config.write(open("db.ini", mode="w"))

六.正则表达式

?先, 我们在??上进?注册或者登陆的时候经常能看到?些格式上的错误提?. 比如:
你在注册百度账号的时候 https://passport.baidu.com/v2/?reg&regType=1&tpl=wk 输入?户
名随意的输入系统会提?你. 你的账号过?或者不允许使?中?等等操作. 那这种操作如果使
?我们现有的知识点是可以完成的. 但是完成的效果并不好. 写起来也不容易. 尤其是对邮箱
的匹配. 电话号码的匹配. 那正则表达式就是专?来处理类似问题的?种表达式. 英?全
称: Regular Expression. 简称 regex或者re. 但你要知道我们在使?python的re模块之前. 我
们?先要对正则有?定的了解和认识. 就像我们使?time模块之前. 我们已经对时间有了?定
的认识.

　　正则表达式是对字符串操作的?种逻辑公式. 我们?般使?正则表达式对字符串进?匹
配和过滤. 使?正则的优缺点:

　　优点: 灵活, 功能性强, 逻辑性强.
　　缺点: 上?难. ?旦上?, 会爱上这个东?
　?具: 各??本编辑器?般都有正则匹配功能. 我们也可以去

http://tool.chinaz.com/regex/ 进?在线测试.

　　正则表达式由普通字符和元字符组成. 普通字符包含??写字?, 数字. 在匹配普通字符
的时候我们直接写就可以了. 比如"abc" 匹配的就是"abc". 我们如果?python也可以实现相
同的效果. 所以普通字符没什么好说的. 重点在元字符上.

　　元字符: 元字符才是正则表达式的灵魂. 元字符中的内容太多了, 在这?我们只介绍?些
常?的.
　　  1. 字符组
　　　　字符组很简单?[]括起来. 在[]中出现的内容会被匹配. 例如:[abc] 匹配a或b或c
　　　　如果字符组中的内容过多还可以使?- , 例如: [a-z] 匹配a到z之间的所有字? [0-9]
匹配所有阿拉伯数字
　　　　思考: [a-zA-Z0-9]匹配的是什么?
　　2. 简单元字符
　　　　基本的元字符. 这个东??上?搜??堆. 但是常?的就那么?个:

. 匹配除换?符以外的任意字符
\w 匹配字?或数字或下划线
\s 匹配任意的空?符
\d 匹配数字
\n 匹配?个换?符
\t 匹配?个制表符
\b 匹配?个单词的结尾
^ 匹配字符串的开始
$ 匹配字符串的结尾
\W 匹配?字?或数字或下划线
\D 匹配?数字
\S 匹配?空?符
a|b 匹配字符a或字符b
() 匹配括号内的表达式，也表示?个组
[...] 匹配字符组中的字符
[^...] 匹配除了字符组中字符的所有字符

　　3. 量词
　　    我们到?前匹配的所有内容都是单??字符号. 那如何?次性匹配很多个字符呢,
我们要?到量词

* 重复零次或更多次
+ 重复?次或更多次
? 重复零次或?次
{n} 重复n次
{n,} 重复n次或更多次
{n,m} 重复n到m次

　　4. 惰性匹配和贪婪匹配
　　　在量词中的*, +,{} 都属于贪婪匹配. 就是尽可能多的匹配到结果.

str: 麻花藤昨天让英雄联盟关服了
reg: 麻花藤.*
此时匹配的是整句话

　　　　在使?.*后?如果加了? 则是尽可能的少匹配. 表?惰性匹配

str: 麻花藤昨天让英雄联盟关服了
reg: 麻花藤.*?
此时匹配的是 麻花藤
str: <div>胡辣汤</div>
reg: <.*>
结果: <div>胡辣汤</div>
str: <div>胡辣汤</div>
reg: <.*?>
结果:
 <div>
 </div>
str: <div>胡辣汤</div>
reg: <(div|/div*)?>
结果:
 <div>
 </div>

　　.*?x的特殊含义 找到下?个x为?.

str: abcdefgxhijklmn
reg: .*?x
结果:abcdefgx

　　5. 分组
　　　在正则中使?()进?分组. 比如. 我们要匹配?个相对复杂的?份证号. ?份证号分
成两种. 老的?份证号有15位. 新的?份证号有18位. 并且新的?份证号结尾有可能是x.

给出以下正则:
^[1-9]\d{13,16}[0-9x]$
^[1-9]\d{14}(\d{2}[0-9x])?$
^([1-9]\d{16}[0-9x]|[1-9]\d{14})$

　　6. 转义
　　　在正则表达式中, 有很多有特殊意义的是元字符, ?如\n和\s等,如果要在正则中匹
配正常的"\n"?不是"换?符"就需要对"\"进?转义, 变成‘\\‘.在python中, ?论是正则表达式, 还
是待匹配的内容, 都是以字符串的形式出现的, 在字符串中\也有特殊的含义, 本身还需要转
义. 所以如果匹配?次"\n", 字符串中要写成‘\\n‘, 那么正则?就要写成"\\\\n",这样就太麻烦了.
这个时候我们就?到了r‘\n‘这个概念, 此时的正则是r‘\\n‘就可以了

　　练习:
　　　1. 匹配邮箱
　　　2. 匹配?机号
　　　3. 匹配??. ?期格式(yyyy-MM-dd)
　　　4. 匹配电话号码
　　　5. 匹配IP

七.re模块:

　re模块是python提供的?套关于处理正则表达式的模块. 核?功能有四个:
　　1. findall 查找所有. 返回list

lst = re.findall("m", "mai le fo len, mai ni mei!")
print(lst) # [‘m‘, ‘m‘, ‘m‘]
lst = re.findall(r"\d+", "5点之前. 你要给我5000万")
print(lst) # [‘5‘, ‘5000‘]

　　2. search 会进?匹配. 但是如果匹配到了第?个结果. 就会返回这个结果. 如果匹配不
上search返回的则是None

ret = re.search(r‘\d‘, ‘5点之前. 你要给我5000万‘).group()
print(ret) # 5

　　3. match 只能从字符串的开头进?匹配

ret = re.match(‘a‘, ‘abc‘).group()
print(ret) # a

　　4. finditer 和findall差不多. 只不过这时返回的是迭代器

it = re.finditer("m", "mai le fo len, mai ni mei!")
for el in it:
 print(el.group()) # 依然需要分组

　　5. 其他操作

ret = re.split(‘[ab]‘, ‘qwerafjbcd‘) # 先按‘a‘分割得到‘qwer‘和‘fjbcd‘,在
对‘qwer‘和‘fjbcd‘分别按‘b‘分割
print(ret) # [‘qwer‘, ‘fj‘, ‘cd‘]
ret = re.sub(r"\d+", "_sb_", "alex250taibai250wusir250ritian38") # 把字符串中
的数字换成__sb__
print(ret) # alex_sb_taibai_sb_wusir_sb_ritian_sb_
ret = re.subn(r"\d+", "_sb_", "alex250taibai250wusir250ritian38") # 将数字替
换成‘__sb__‘，返回元组(替换的结果,替换了多少次)
print(ret) # (‘alex_sb_taibai_sb_wusir_sb_ritian_sb_‘, 4)
obj = re.compile(r‘\d{3}‘) # 将正则表达式编译成为?个 正则表达式对象, 规则要匹配的
是3个数字
ret = obj.search(‘abc123eeee‘) # 正则表达式对象调?search, 参数为待匹配的字符串
print(ret.group()) # 结果: 123
爬?重点:
obj = re.compile(r‘(?P<id>\d+)(?P<name>e+)‘) # 从正则表达式匹配的内容每个组起名
字
ret = obj.search(‘abc123eeee‘) # 搜索
print(ret.group()) # 结果: 123eeee
print(ret.group("id")) # 结果: 123 # 获取id组的内容
print(ret.group("name")) # 结果: eeee # 获取name组的内容

　　6. 两个坑
　　注意: 在re模块中和我们在线测试?具中的结果可能是不?样的.

ret = re.findall(‘www.(baidu|oldboy).com‘, ‘www.oldboy.com‘)
print(ret) # [‘oldboy‘] 这是因为findall会优先把匹配结果组?内容返回,如果想要匹
配结果,取消权限即可
ret = re.findall(‘www.(?:baidu|oldboy).com‘, ‘www.oldboy.com‘)
print(ret) # [‘www.oldboy.com‘]

　　split?也有?个坑

ret=re.split("\d+","eva3egon4yuan")
print(ret) #结果 ： [‘eva‘, ‘egon‘, ‘yuan‘]
ret=re.split("(\d+)","eva3egon4yuan")
print(ret) #结果 ： [‘eva‘, ‘3‘, ‘egon‘, ‘4‘, ‘yuan‘]
#在匹配部分加上（）之后所切出的结果是不同的，
#没有（）的没有保留所匹配的项，但是有（）的却能够保留了匹配的项，
#这个在某些需要保留匹配部分的使?过程是?常重要的。

　　这种优先级的问题有时候会帮我们完成很多功能. 我们来看?个比较复杂的例?

import re
from urllib.request import urlopen
import ssl
# ?掉数字签名证书
ssl._create_default_https_context = ssl._create_unverified_context
def getPage(url):
 response = urlopen(url)
 return response.read().decode(‘utf-8‘)
def parsePage(s):
 ret = re.findall(
 ‘<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>\d+).*?
<span class="title">(?P<title>.*?)</span>‘
 ‘.*?<span class="rating_num" .*?>(?P<rating_num>.*?)</span>.*?<span>
(?P<comment_num>.*?)评价</span>‘, s, re.S)
 return ret
def main(num):
 url = ‘https://movie.douban.com/top250?start=%s&filter=‘ % num
 response_html = getPage(url)
 ret = parsePage(response_html)
 print(ret)
count = 0
for i in range(10): # 10?
 main(count)
 count += 25

　　此时利?的就是分组之后. 匹配成功后获取到的是分组后的结果. (?P<id>\d+) 此时当前
组所匹配的数据就会被分组到id组内. 此时程序可以改写成:

import ssl
import re
from urllib.request import urlopen
# ?掉数字签名证书
ssl._create_default_https_context = ssl._create_unverified_context
def getPage(url):
 response = urlopen(url)
 return response.read().decode(‘utf-8‘)
def parsePage(s):
 com = re.compile(
 ‘<div class="item">.*?<div class="pic">.*?<em .*?>(?P<id>\d+).*?
<span class="title">(?P<title>.*?)</span>‘
 ‘.*?<span class="rating_num" .*?>(?P<rating_num>.*?)</span>.*?
<span>(?P<comment_num>.*?)评价</span>‘, re.S)
 ret = com.finditer(s)
 for i in ret:
 yield {
 "id": i.group("id"),
 "title": i.group("title"),
 "rating_num": i.group("rating_num"),
 "comment_num": i.group("comment_num"),
 }
def main(num):
 url = ‘https://movie.douban.com/top250?start=%s&filter=‘ % num
 response_html = getPage(url)
 ret = parsePage(response_html)
 # print(ret)
 f = open("move_info7", "a", encoding="utf8")
 for obj in ret:
 print(obj)
 data = str(obj)
 f.write(data + "\n")
count = 0
for i in range(10):
 main(count)
 count += 25

　　正则表达式和re模块就说这么多. 如果要把正则所有的内容全部讲清楚讲明?, ?少要?周
以上的时间. 对于我们?常使???. 上述知识点已经够?了. 如果碰到?些极端情况建议想
办法分部处理. 先对字符串进?拆分. 然后再考虑?正则.

原文地址：https://www.cnblogs.com/Ajie-boby/p/10268196.html