爬虫的解析方式三：正则表达式-Python教程-PHP中文网

众多语言都能进行爬虫，但基于python的爬虫显得更加简洁，方便。爬虫也成了python语言中必不可少的一部分。爬虫的解析方式也是多种多样。

上一篇给大家讲解的是爬虫的解析方式二：Beautifulsoup，今天给带给大家的是正则表达式。

正则表达式

正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。就是事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符”，这个“规则字符” 来表达对字符的一种过滤逻辑。

正则并不是python独有的，其他语言也都有正则。

python中的正则，封装了re模块

Python中常用的正则表达式处理函数

re.match函数

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

函数语法：

re.match(pattern, string, flags=0)

登录后复制

函数参数说明：

参数描述

pattern 匹配的正则表达式

string 要匹配的字符串。

flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

匹配成功re.match方法返回一个匹配的对象，否则返回None。

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

匹配对象方法 描述

group(num=0) 匹配的整个表达式的字符串，group() 可以一次输入多个组号，

在这种情况下它将返回一个包含那些组所对应值的元组。

groups() 返回一个包含所有小组字符串的元组，从 1 到所含的小组号。

import re
print(re.match('www', 'www.baidu.com').span())  # 在起始位置匹配
print(re.match('com', 'www.baidu.com'))         # 不在起始位置匹配

登录后复制

以上实例运行输出结果为：

(0, 3)
None

登录后复制

import re
content = "Cats are smarter than dogs"
result = re.match( r'(.*) are (.*?) .*', content)
print(result.group())
print(result.group(1))
print(result.group(2))

登录后复制

以上实例执行结果如下：

Cats are smarter than dogs
Cats
smarter
result.group()获取匹配的结果
result.span()获去匹配字符串的长度范围

登录后复制

泛匹配

其实相对来说上面的方式并不是非常方便，其实可以将上述的正则规则进行更改

import re
content = "Cats are smarter than dogs"
result = re.match( r'Cats.*dogs$', content)
print(result)
print(result.group())
print(result.span())

登录后复制

匹配目标

如果为了匹配字符串中具体的目标，则需要通过（）括起来，例子如下：

import re
content = "Cats are 1234567 smarter than dogs"
result = re.match( r'(.*)sares(d+)s(.*?)s.*', content) #s匹配空格符 d+匹配数字
print(result.group())
print(result.group(1))
print(result.group(2))

登录后复制

以下为执行结果：

Cats are smarter than dogs

Cats

1234567

贪婪匹配

先看下面代码：

import re
content = "Cats are 1234567 smarter than dogs"
result = re.match( r'Cats.*(d+).*dogs', content) 
print(result.group())
print(result.group(1))

登录后复制

从结果中可以看出只匹配到了7，并没有匹配到1234567，出现这种情况的原因是前面的.* 给匹配掉了， .*在这里会尽可能的匹配多的内容，也就是我们所说的贪婪匹配，

如果我们想要匹配到1234567则需要将正则表达式改为：

result = re.match( r'Cats.*？(d+).*dogs', content)

这样结果就可以匹配到1234567

匹配模式

很多时候匹配的内容是存在换行的问题的，这个时候的就需要用到匹配模式re.S来匹配换行的内容

import re
content = """Cats are 1234567 smarter than dogs
dogs are wangwangwang"""
result = re.match( r'Cats.*(d+).*wangwangwang', content,re.S) 
print(result.group())
print(result.group(1))

登录后复制

转义

当我们要匹配的内容中存在特殊字符的时候，就需要用到转移符号,例子如下：

import re
content= "price is $5.00"
result = re.match('price is $5.00',content)
print(result.group())

登录后复制

注意：

对上面的一个小结：

尽量使用泛匹配，使用括号得到匹配目标，尽量使用非贪婪模式，有换行符就用re.S

强调re.match是从字符串的起始位置匹配一个模式

re.search方法

re.search 扫描整个字符串并返回第一个成功的匹配。

函数语法：

re.search(pattern, string, flags=0)

登录后复制

函数参数说明：

参数描述

pattern 匹配的正则表达式

string 要匹配的字符串。

flags 标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

匹配成功re.search方法返回一个匹配的对象，否则返回None。

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。

匹配对象方法 描述

group(num=0) 匹配的整个表达式的字符串，group() 可以一次输入多个组号，

在这种情况下它将返回一个包含那些组所对应值的元组。

groups() 返回一个包含所有小组字符串的元组，从 1 到所含的小组号。

import re
content = "extra things hello 123455 world_this is a Re Extra things"
result = re.search("hello.*?(d+).*?Re",content)
print(result.group())
print(result.group(1)

登录后复制

其实这个时候我们就不需要在写^以及$，因为search是扫描整个字符串

注意：所以为了匹配方便，我们会更多的用search，不用match,match必须匹配头部，所以很多时候不是特别方

re.match与re.search的区别

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

html = '''<div id="songs-list">
    <h2 class="title">经典老歌</h2>
    <p class="introduction">
        经典老歌列表
    </p>
    <ul id="list" class="list-group">
        <li data-view="2">一路上有你</li>
        <li data-view="7">
            <a href="/2.mp3" singer="任贤齐">沧海一声笑</a>
        </li>
        <li data-view="4" class="active">
            <a href="/3.mp3" singer="齐秦">往事随风</a>
        </li>
        <li data-view="6"><a href="/4.mp3" singer="beyond">光辉岁月</a></li>
        <li data-view="5"><a href="/5.mp3" singer="陈慧琳">记事本</a></li>
        <li data-view="5">
            <a href="/6.mp3" singer="邓丽君">但愿人长久</a>
        </li>
    </ul>
</div>'''

登录后复制

import re
 
result = re.search('<li.*?active.*?singer="(.*?)">(.*?)</a>',html,re.S)
print(result.group(1), result.group(2))

登录后复制

观察到

节点，其中
节点有的包含节点，有的不包含节点，节点还有一些相应的属性，超链接和歌手名。
首先我们尝试提取class为active的
节点内部的超链接包含的歌手名和歌名。
所以我们需要提取第三个

节点下的节点的singer属性和文本。
所以正则表达式可以以
开头，然后接下来寻找一个标志符active，中间的部分可以用.*?来匹配，然后接下来我们要提取singer这个属性值，所以还需要写入singer="(.*?)"，我们需要提取的部分用小括号括起来，以便于用group()方法提取出来，它的两侧边界是双引号，然后接下来还需要匹配节点的文本，那么它的左边界是>，右边界是，所以我们指定一下左右边界，然后目标内容依然用(.*?)来匹配，所以最后的正则表达式就变成了

(.*?)

另外由于代码有换行，所以这里第三个参数需要传入re.S

注意：在上面两次匹配中，search()方法的第三个参数我们都加了re.S，使得.*?可以匹配换行，所以含有换行的

节点被匹配到了，如果我们将其去掉，只会匹配到不换行的的内容
re.findall

搜索整个字符串然后返回匹配正则表达式的所有内容
```
html = '''<div id="songs-list">
    <h2 class="title">经典老歌</h2>
    <p class="introduction">
        经典老歌列表
    </p>
    <ul id="list" class="list-group">
        <li data-view="2">一路上有你</li>
        <li data-view="7">
            <a href="/2.mp3" singer="任贤齐">沧海一声笑</a>
        </li>
        <li data-view="4" class="active">
            <a href="/3.mp3" singer="齐秦">往事随风</a>
        </li>
        <li data-view="6"><a href="/4.mp3" singer="beyond">光辉岁月</a></li>
        <li data-view="5"><a href="/5.mp3" singer="陈慧琳">记事本</a></li>
        <li data-view="5">
            <a href="/6.mp3" singer="邓丽君">但愿人长久</a>
        </li>
    </ul>
</div>'''
```
登录后复制
登录后复制
```
import re
results = re.findall('<li.*?href="/(.*?)".*?singer="(.*?)">(.*?)</a>', html, re.S)
for result in results:
    print(result)
    print(result[0], result[1], result[2])
```
登录后复制
运行结果：

('2.mp3', '任贤齐', '沧海一声笑')

2.mp3 任贤齐沧海一声笑

('3.mp3', '齐秦', '往事随风')

3.mp3 齐秦往事随风

('4.mp3', 'beyond', '光辉岁月')

4.mp3 beyond 光辉岁月

('5.mp3', '陈慧琳', '记事本')

5.mp3 陈慧琳记事本

('6.mp3', '邓丽君', '但愿人长久')

6.mp3 邓丽君但愿人长久
```
results = re.findall('<li.*?>s*?(<a.*?>)?(w+)(</a>)?s*?</li>',html,re.S)
for result in results:
    #print(result)
    print(result[0], result[1], result[2])
```
登录后复制
运行结果：

一路上有你

沧海一声笑

往事随风

光辉岁月

记事本

但愿人长久

s*? 这种用法其实就是为了解决有的有换行，有的没有换行的问题

()? 这种用法是因为html中有的有a标签，有的没有的，？表示匹配一个或0个，正好可以用于匹配

检索和替换

Python 的re模块提供了re.sub用于替换字符串中的匹配项。

语法：

re.sub(pattern, repl, string, count=0)

参数：

pattern : 正则中的模式字符串。

repl : 替换的字符串，也可为一个函数。

string : 要被查找替换的原始字符串。

count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
```
import re
phone = "2004-959-559 # 这是一个电话号码"
# 删除注释
num = re.sub(r'#.*$', "", phone)
print ("电话号码 : ", num)
 
# 移除非数字的内容
num = re.sub(r'D', "", phone)
print ("电话号码 : ", num)
```
登录后复制
在这里我们只需要在第一个参数传入D来匹配所有的数字，然后第二个参数“”是替换成的字符串，要去掉的话就可以赋值为空，第三个参数phone就是原字符串。

re.compile

将正则表达式编译成正则表达式对象，方便复用该正则表达式
```
import re
content= "hello world fan"
 
pattern =re.compile("hello.*fan",re.S)
 
result1 = re.match(pattern,content)
result2 = re.search(pattern,content)
result3 = re.sub(pattern, '', content)
print(result1, result2, result3)
```
登录后复制
compile()还可以传入修饰符，例如re.S等修饰符，这样在search()、findall()等方法中就不需要额外传了。所以compile()方法可以说是给正则表达式做了一层封装，以便于我们更好地复用。

正则表达式修饰符 - 可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

修饰符 描述

re.I 使匹配对大小写不敏感

re.L 做本地化识别（locale-aware）匹配

re.M 多行匹配，影响 ^ 和 $

re.S 使 . 匹配包括换行在内的所有字符

re.U 根据Unicode字符集解析字符。这个标志影响 w, W, , B.

re.X 该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

正则表达式模式

模式字符串使用特殊的语法来表示一个正则表达式：

字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。

多数字母和数字前加一个反斜杠时会拥有不同的含义。

标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。

反斜杠本身需要使用反斜杠转义。

由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r' '，等价于 \t )匹配相应的特殊字符。

下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。

模式描述

^ 匹配字符串的开头

$ 匹配字符串的末尾。

. 匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。

[...] 用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'

[^...] 不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。

re* 匹配0个或多个的表达式。

re+ 匹配1个或多个的表达式。

re? 匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式

re{ n}

re{ n,} 精确匹配n个前面表达式。

re{ n, m} 匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式

a| b 匹配a或b

(re) G 匹配括号内的表达式，也表示一个组

(?imx) 正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。

(?-imx) 正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。

(?: re) 类似 (...), 但是不表示一个组

(?imx: re) 在括号中使用i, m, 或 x 可选标志

(?-imx: re) 在括号中不使用i, m, 或 x 可选标志

(?#...) 注释.

(?= re) 前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，

否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；

模式的剩余部分还要尝试界定符的右边。

(?! re) 向前否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功

(?> re) 匹配的独立模式，省去回溯。

w 匹配字母数字

W 匹配非字母数字

s 匹配任意空白字符，等价于 [ ].

S 匹配任意非空字符

d 匹配任意数字，等价于 [0-9].

D 匹配任意非数字

A 匹配字符串开始

Z 匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。c

z 匹配字符串结束

G 匹配最后匹配完成的位置。

匹配一个单词边界，也就是指单词和空格间的位置。

例如， 'er' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。

B 匹配非单词边界。'erB' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。

, , 等. 匹配一个换行符。匹配一个制表符。等

...9 匹配第n个分组的内容。

匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式。

正则表达式实例

字符匹配

实例描述

python 匹配 "python".

字符类

实例描述

[Pp]ython 匹配 "Python" 或 "python"

rub[ye] 匹配 "ruby" 或 "rube"

[aeiou] 匹配中括号内的任意一个字母

[0-9] 匹配任何数字。类似于 [0123456789]

[a-z] 匹配任何小写字母

[A-Z] 匹配任何大写字母

[a-zA-Z0-9] 匹配任何字母及数字

[^aeiou] 除了aeiou字母以外的所有字符

[^0-9] 匹配除了数字外的字符

特殊字符类

实例描述

. 匹配除 " " 之外的任何单个字符。要匹配包括 ' ' 在内的任何字符，请使用象 '[. ]' 的模式。

d 匹配一个数字字符。等价于 [0-9]。

D 匹配一个非数字字符。等价于 [^0-9]。

s 匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ ]。

S 匹配任何非空白字符。等价于 [^ ]。

w 匹配包括下划线的任何单词字符。等价于'[A-Za-z0-9_]'。

W 匹配任何非单词字符。等价于 '[^A-Za-z0-9_]'。

以上就是爬虫的解析方式三：正则表达式的详细内容，更多请关注php中文网其它相关文章！