爬虫匹配之正则（一）
正则
一、正则基础
1、为什么使用正则
-
需求
判断一个字符串是否是手机号
-
解决
编写一个函数，给函数一个字符串，如果是手机号则返回True，否则返回False
-
代码
def isPhone(phone): # 长度为11 # 全部都是数字字符 # 以1开头 pass if isPhone("13812345678"): print("是手机号") else: print("不是手机号") -
注意
如果使用正则会让这个问题变得简单
2、正则与re模块简介
概述： 正则表达式，又称规则表达式
正则表达式(regular expression)描述了一种字符串匹配的模式（pattern）
正则匹配是一个 模糊的匹配(不是精确匹配)
re：python自1.5版本开始增加了re模块，该模块提供了perl风格的正则表达式模式，re模块是python语言拥有了所有正则表达式的功能
- 如下四个方法经常使用
- match()
- search()
- findall()
- finditer()
二、正则表达式
1、匹配单个字符与数字
| 匹配 | 说明 |
|---|---|
| . | 匹配除换行符以外的任意字符，当flags被设置为re.S时，可以匹配包含换行符以内的所有字符，如果没有设置并且还匹配所有字符需要[.\n] |
| [] | 里面是字符集合，匹配[]里任意一个字符 |
| [0123456789] | 匹配任意一个数字字符 |
| [0-9] | 匹配任意一个数字字符 |
| [a-z] | 匹配任意一个小写英文字母字符 |
| [A-Z] | 匹配任意一个大写英文字母字符 |
| [A-Za-z] | 匹配任意一个英文字母字符 |
| [A-Za-z0-9] | 匹配任意一个数字或英文字母字符 |
| [^lucky] | []里的^称为脱字符，表示非，匹配不在[]内的任意一个字符 |
| [1] | 以[]里的某个字符作为开头 |
| \d | 匹配任意一个数字字符，相当于[0-9] |
| \D | 匹配任意一个非数字字符，相当于[^0-9] |
| \w | 匹配字母、下划线、数字中的任意一个字符，相当于[0-9A-Za-z_] |
| \W | 匹配非字母、下划线、数字中的任意一个字符，相当于[^0-9A-Za-z_] |
| \s | 匹配空白符(空格、换页、换行、回车、制表)，相当于[ \f\n\r\t] |
| \S | 匹配非空白符(空格、换页、换行、回车、制表)，相当于[^ \f\n\r\t] |
2、匹配锚字符
锚字符:用来判定是否按照规定开始或者结尾
| 匹配 | 说明 |
|---|---|
| ^ | 行首匹配，和[]里的^不是一个意思 |
| $ | 行尾匹配 |
| \A | 匹配字符串的开始，和^的区别是\A只匹配整个字符串的开头，即使在re.M模式下也不会匹配其他行的行首 |
| \Z | 匹配字符串的结尾，和$的区别是\Z只匹配整个字符串的结尾，即使在re.M模式下也不会匹配其他行的行尾 |
3、限定符
限定符用来指定正则表达式的一个给定组件必须要出现多少次才能满足匹配。有 * 或 + 或 ? 或 {n} 或 {n,} 或 {n,m} 共6种。
| 匹配 | 说明 |
|---|---|
| (xyz) | 匹配括号内的xyz，作为一个整体去匹配 一个单元 子存储 |
| x? | 匹配0个或者1个x，非贪婪匹配 |
| x* | 匹配0个或任意多个x |
| x+ | 匹配至少一个x |
| x | 确定匹配n个x，n是非负数 |
| x | 至少匹配n个x |
| x | 匹配至少n个最多m个x |
| x|y | |表示或的意思，匹配x或y |
示例
1.[] #代表原子表 存储表达式 字符集合。匹配所包含的任意一个字符
[a] #匹配一个字母a
[abc] #匹配字母a/b/c
[a-z] #匹配任意一位小写字母
[AaBb] #匹配任意一位大小写字母a/b
[a-zA-Z] #匹配任意一位字母
[0-9] #匹配任意一位数字
[a-zA-Z0-9] #匹配任意一位数字或字母
2. ^ #以什么开头 在原子表外开头 以什么...开头 在原子表内 取反 相当于 \A
[^a-z] #小写字母以外的字符
^a[a-zA-Z] #匹配 以字母a开头的俩位字母
^[a-zA-Z] #以任意一位字母开头的字符
3. $ #以...结尾 ^和 $ 搭配来使用的 这样才能够真正的去限制你匹配的内容和长度 相当于\Z
^1[3-8][0-9]{9}$ #匹配手机号
^1[38][0-9]{9}$ #匹配手机号
4.{m} #表示前面的数量m个 不能单独使用
[a][a][a] #匹配3个a
a{3}
[a-zA-Z]{3} #匹配任意3位字母
^[a-zA-Z]{3} #匹配任意3位字母作为开头的字符串
^[a-zA-Z]{3}[0-9]{8}$
5.{m,n} #表示前面的数量m-n个 不能单独使用
^[1-9][0-9]{4,10}$#匹配QQ号
6.{m,} #表示前面的数量至少m个 不能单独使用
7. ? # 可有可无 匹配前面的子表达式零次或一次，或指明一个非贪婪限定符。要匹配 ? 字符，请使用 \?
[1-9][0-9]?
[1-9][0-9]{0,1}
-?[1-9] #一位整数
8. . #匹配换行符\n以外的任意字符
9. * #匹配前面字符任意次{0,}
10. .* #匹配换行符以外任意字符任意次 （贪婪模式）
11. .*? #匹配换行符以外任意字符任意次 (非贪婪模式)
12. + #表示匹配数量 最少 1次 {1,}
13. .+ #表示匹配换行符 以外的任意字符 至少一次 （贪婪模式）
14. .+? #表示匹配换行符 以外的任意字符 至少一次 （非贪婪模式）
15. () #1.一个单元 2.子存储
(?P<起别名>)
(?:pattern) #只做为一个单元使用 而不是作为子存储
(?=pattern) #返回不包含括号里面的值
re.findall("Windows(?=95|98|NT|2000)",'WindowsNT')#Windows
(?!pattern) #与上面的相反 只要后面的不想等 就会将前面的内容匹配返回
16. | #表示或
[ab] 等同于 （a|b) # 匹配字母a或者b
res = re.search('(?P<qq>^[1-9][0-9]{4,10}$)|(?P<phone>^1[3-8][0-9]{9}$)', '1833904571') # 手机号码或qq号码
常用组合
[.*?]
[\s\S]
4、练习
^[a-zA-Z0-9_]{1,}$所有包含一个以上的字母、数字或下划线的字符串^[a-zA-Z0-9_]+$所有包含一个以上的字母、数字或下划线的字符串^\-{0,1}[0-9]{1,}$所有的整数^[1-9][0-9]{0,}$所有的正整数^[-]?[0-9]+\.?[0-9]+$所有的浮点数^\-?[0-9]+\.?[0-9]*$所有的浮点数^[1-9][0-9]*$所有的正整数^\-?[0-9]+$所有的整数^\-?[0-9]{1,}\.?[0-9]{1,}$以上正负整数浮点数的简写
三、re模块中常用函数
通用flags（修正符）
| 值 | 说明 |
|---|---|
| re.I | 是匹配对大小写不敏感 |
| re.L | 做本地化识别匹配 |
| re.M | 多行匹配，影响到^和$ |
| re.S | 使.匹配包括换行符在内的所有字符 |
| re.U | 根据Unicode字符集解析字符，影响\w、\W、\b、\B |
| re.X | 通过给予我们功能灵活的格式以便更好的理解正则表达式 |
通用函数
-
获取匹配结果
-
使用group()方法 获取到匹配的值
-
groups() 返回一个包含所有小组字符串的元组(也就是自存储的值)，从 1 到 所含的小组号。
-
-
获取匹配后的索引位置
obj.span()
1、match()函数
-
原型
def match(pattern, string, flags=0) -
功能
匹配成功返回 匹配的对象
匹配失败 返回 None
-
获取匹配结果
-
使用group()方法 获取到匹配的值
-
groups() 返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。
-
-
获取匹配后的索引位置
obj.span()
-
注意：从第一位开始匹配 只匹配一次
-
参数
参数 说明 pattern 匹配的正则表达式(一种字符串的模式) string 要匹配的字符串 flags 标识位，用于控制正则表达式的匹配方式 -
代码
import re res = re.match('\d{2}','123') print(res.group()) print(res.span()) #给当前匹配到的结果起别名 s = '3G4HFD567' re.match("(?P<value>\d+)",s) print(x.group(0)) print(x.group('value'))
2、searce()函数
-
原型
def search(pattern, string, flags=0) -
功能
扫描整个字符串string，并返回第一个pattern模式成功的匹配
匹配失败 返回 None
-
参数
参数 说明 pattern 匹配的正则表达式(一种字符串的模式) string 要匹配的字符串 flags 标识位，用于控制正则表达式的匹配方式 -
注意：
只要字符串包含就可以
只匹配一次
-
示例
import re res = re.search('[a-z]', '131A3ab889s') print(res) print(res.span()) print(res.group()
-
注意
与search的区别
相同点：
都只匹配一次
不同点：
- search是在要匹配的字符串中 包含正则表达式的内容就可以
- match 必须第一位就开始匹配 否则匹配失败
3、findall()函数（返回列表）
-
原型
def findall(pattern, string, flags=0) -
功能
扫描整个字符串string，并返回所有匹配的pattern模式结果的字符串列表
-
参数
参数 说明 pattern 匹配的正则表达式(一种字符串的模式) string 要匹配的字符串 flags 标识位，用于控制正则表达式的匹配方式 -
示例
myStr = """ <a href="http://www.baidu.com">百度</a> <A href="http://www.taobao.com">淘宝</A> <a href="http://www.id97.com">电 影网站</a> <i>我是倾斜1</i> <i>我是倾斜2</i> <em>我是倾斜2</em> """ # html里是不区分大小写 # （1）给正则里面匹配的 加上圆括号 会将括号里面的内容进行 单独的返回 res = re.findall("(<a href=\"http://www\.(.*?)\.com\">(.*?)</a>)",myStr) #[('<a href="http://www.baidu.com">百度</a>', 'baidu', '百度')] # 括号的区别 res = re.findall("<a href=\"http://www\..*?\.com\">.*?</a>",myStr) #['<a href="http://www.baidu.com">百度</a>'] #(2) 不区分大小写的匹配 res = re.findall("<a href=\"http://www\..*?\.com\">.*?</a>",myStr,re.I) #['<a href="http://www.baidu.com">百度</a>', '<A href="http://www.taobao.com">淘宝</A>'] res = re.findall("<[aA] href=\"http://www\..*?\.com\">.*?</[aA]>",myStr) #['<a href="http://www.baidu.com">百度</a>'] # (3) 使.支持换行匹配 res = re.findall("<a href=\"http://www\..*?\.com\">.*?</a>",myStr,re.S) # # (4) 支持换行 支持不区分大小写匹配 res = re.findall("<a href=\"http://www\..*?\.com\">.*?</a>",myStr,re.S|re.I) # print(res) -
贪婪与非贪婪模式
<H1>Chapter 1 - 介绍正则表达式</H1>贪婪：下面的表达式匹配从开始小于符号 (<) 到关闭 H1 标记的大于符号 (>) 之间的所有内容。
/<.*>/非贪婪：如果您只需要匹配开始和结束 H1 标签，下面的非贪婪表达式只匹配
。
/<.*?>/如果只想匹配开始的 H1 标签，表达式则是：
/<\w+?>
4、finditer()函数
-
原型
def finditer(pattern, string, flags=0) -
功能
与findall()类似，返回一个迭代器
-
参数
参数 说明 pattern 匹配的正则表达式(一种字符串的模式) string 要匹配的字符串 flags 标识位，用于控制正则表达式的匹配方式 -
代码
import re res = re.finditer('\w', '12hsakda1') print(res) print(next(res)) for i in res: print(i)
5、split()函数
-
作用：切割字符串
-
原型：
def split(patter, string, maxsplit=0, flags=0) -
参数
pattern 正则表达式
string 要拆分的字符串
maxsplit 最大拆分次数 默认拆分全部
flags 修正符
-
示例
import re myStr = "asdas\rd&a\ts12d\n*a3sd@a_1sd" #通过特殊字符 对其进行拆分 成列表 res = re.split("[^a-z]",myStr) res = re.split("\W",myStr)
6、字符串替换
-
函数：sub()/subn()函数
-
作用
在目标字符串string中查找匹配的pattern模式的字符串，再把它们替换成指定repl字符串，可以指定最多替换count次，否则替换所有
-
原型
def sub(pattern, repl, string, count=0, flags=0) 返回匹配后的结果 def subn(pattern, repl, string, count=0, flags=0) 返回匹配后的结果和次数 -
参数
- pattern : 正则中的模式字符串。
- repl : 替换的字符串，也可为一个函数。
- string : 要被查找替换的原始字符串。
- count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
- flags 修正符
-
区别
a、sub返回一个替代后的字符串
b、subn返回一个元组，元组的第一个元素为替换后的字符串，第二个元素为替换的次数
-
示例
import re # 将匹配的数字乘于 2 def double(matched): value = int(matched.group('value')) return str(value * 2) s = 'A23G4HFD567' print(re.sub('(?P<value>\d+)', double, s))进阶
myStr = "2017/10/1" #10-1-2017 res = re.search("[0-9]{4}/[0-9]{2}/[0-9]",myStr) myStr = "<b>加粗1</b><i>倾斜3</i><b>加粗2</b>" # html = '<i>我是b标签</i><i>我是加粗标签</i>' # 将b标签换成i标签 #用到了括号的子存储 通过\\1-\\n进行取值 \\1-\\n的顺序 就是你()的顺序 res = re.sub("<b>", "<i>", html) res = re.sub("<b>(.*?)</b>", "<i>\\1</i>", html) print(res) # 2021/08/26 替换成 08-26-2021 print(re.sub('(\d{4})/(\d{2})/(\d{2})','\\2-\\3-\\1', '2021/08/26'))
8、修正符
-
作用
对正则进行修正
-
使用
search/match/findall/sub/subn/finditer 等函数 flags参数的使用
-
修正符
re.I 不区分大小写匹配
re.M 多行匹配 影响到^ 和 $ 的功能
re.S 使.可以匹配换行符 匹配任意字符
-
使用
re.I
print(re.findall('[a-z]','AaBb')) print(re.findall('[a-z]','AaBb', flags=re.I))re.M
myStr = """asadasdd1\nbsadasdd2\ncsadasdd3""" print(re.findall('^[a-z]',myStr, )) print(re.findall('\A[a-z]',myStr)) print(re.findall('\d$',myStr)) print(re.findall('\d\Z',myStr)) # re.M print(re.findall('^[a-z]',myStr, flags=re.M)) print(re.findall('\A[a-z]',myStr, flags=re.M)) print(re.findall('\d$',myStr, flags=re.M)) print(re.findall('\d\Z',myStr, flags=re.M))re.S
print(re.findall('<b>.*?</b>','<b>b标签</b>')) print(re.findall('<b>.*?</b>','<b>b标\n签</b>', flags=re.S))
四、正则高级
1、分组&起名称
-
概念
处理简单的判断是否匹配之外，正则表达式还有提取子串的功能，用()表示的就是要提取的分组
-
代码
#给当前匹配到的结果起别名 s = '3G4HFD567' re.match("(?P<value>\d+)",s) print(x.group(0)) print(x.group('value')) -
说明
- 正则表达式中定义了组，就可以在Match对象上用group()方法提取出子串来
- group(0)永远是原始字符串，group(1)、group(2)……表示第1、2、……个子串
2、编译
-
概念
当在python中使用正则表达式时，re模块会做两件事，一件是编译正则表达式，如果表达式的字符串本身不合法，会报错。另一件是用编译好的正则表达式提取匹配字符串
-
编译优点
如果一个正则表达式要使用几千遍，每一次都会编译，出于效率的考虑进行正则表达式的编译，就不需要每次都编译了，节省了编译的时间，从而提升效率
-
compile()函数
-
原型
def compile(pattern, flags=0) -
作用
将pattern模式编译成正则对象
-
参数
参数 说明 pattern 匹配的正则表达式(一种字符串的模式) flags 标识位，用于控制正则表达式的匹配方式 -
flags
值 说明 re.I 是匹配对大小写不敏感 re.M 多行匹配，影响到^和$ re.S 使.匹配包括换行符在内的所有字符 -
返回值
编译好的正则对象
-
示例
import re re_phone = re.compile(r"(0\d{2,3}-\d{7,8})") print(re_phone, type(re_phone))
-
-
编译后其他方法的使用
原型
def match(self, string, pos=0, endpos=-1) def search(self, string, pos=0, endpos=-1) def findall(self, string, pos=0, endpos=-1) def finditer(self, string, pos=0, endpos=-1)参数
参数 说明 string 待匹配的字符串 pos 从string字符串pos下标开始 endpos 结束下标 示例
s1 = "lucky's phone is 010-88888888" s2 = "kaige's phone is 010-99999999" ret1 = re_phone.search(s1) print(ret1, ret1.group(1)) ret2 = re_phone.search(s2) print(ret2, ret2.group(1))
3、贪婪与非贪婪
-
贪婪模式
贪婪概念：匹配尽可能多的字符
- .+ 匹配换行符以外的字符至少一次
- .* 匹配换行符以外的字符任意次
实例
res = re.search('<b>.+</b>', '<b></b><b>b标签</b>') res = re.search('<b>.*</b>', '<b>b标签</b><b>b标签</b><b>b标签</b><b>b标签</b>') -
非贪婪模式
非贪婪概念：尽可能少的匹配称为非贪婪匹配，*?、+?即可
-
.+? 匹配换行符以外的字符至少一次 拒绝贪婪
- .*? 匹配换行符以外的字符任意次 拒绝贪婪
实例
res = re.search('<b>.+?</b>', '<b>b标签</b><b>b标签</b>') res = re.search('<b>.*?</b>', '<b>b标签</b><b>b标签</b><b>b标签</b><b>b标签</b>')
五、爬虫抓取模块
urllib.request URL处理模块
1、 urlopen
import urllib.request
#请求url地址
urllib.request.urlopen("URL地址")
#函数
read() #读取全部
readline() #读取一行
readlines()#读取所有以列表形式返回
decode("编码") #根据编码进行解码
getcode() #获取http请求的状态码
geturl() #获取当前正在访问的地址
2、设置请求超时
response = urllib.request.urlopen("http://www.baidu.com", timeout=0.5)
3、网络传输格式的转换
urllib.request.unquote() #转换成正常的格式
urllib.request.quote() #转换成网络传输的格式
4、Request 模拟浏览器请求
request = urllib.request.Request("path",headers={"User-Agent":"请求头"})
urllib.request.urlopen(request)
注意：
import ssl
context = ssl._create_unverified_context()
urllib.request.urlopen(request,context=context)
5、下载
urllib.request.urlretrieve(url,path)
注意：
如果协议存在ssl证书
ssl._create_default_https_context = ssl._create_unverified_context
lucky ↩︎
