爬虫--正则表达式

什么是正则表达式？

正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。

常见匹配表达式：

 re.match

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

re.match(pattern,string,flags=0)
# 第一个为你写的正则表达式，第二个为匹配的目标字符串，第三个为匹配模式

import re
content = "Hello 123 4567 World_This is a Regex Demo"
result = re.match("^Hellosdddsd{4}sw{10}.*Demo$", content)
print(result)
print(result.group()) # 返回匹配结果
print(result.span()) # 输出匹配结果的范围

<_sre.SRE_Match object; span=(0, 41), match='Hello 123 4567 World_This is a Regex Demo'>
Hello 123 4567 World_This is a Regex Demo
(0, 41)

泛匹配

import re
content = "Hello 123 4567 World_This is a Regex Demo"
result = re.match("^Hello.*Demo$", content)
print(result)
print(result.group()) # 返回匹配结果
print(result.span()) # 输出匹配结果的范围

<_sre.SRE_Match object; span=(0, 41), match='Hello 123 4567 World_This is a Regex Demo'>
Hello 123 4567 World_This is a Regex Demo
(0, 41)

匹配目标

import re
content = "Hello 1234567 World_This is a Regex Demo"
result = re.match("^Hellos(d+).*Demo$", content)
print(result)
print(result.group(1)) # group(1)就是把第一个括号里的内容打印出来
print(result.span()) # 输出匹配结果的范围

<_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
1234567
(0, 40)

贪婪匹配

import re
content = "Hello 1234567 World_This is a Regex Demo"
result = re.match("^He.*(d+).*Demo$", content)
print(result)
print(result.group(1)) # group(1)就是把第一个括号里的内容打印出来
print(result.span()) # 输出匹配结果的范围

<_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
7
(0, 40)
#为什么group(1)打印出来得时7呢？而不是上面的1234567？
#因为result = re.match("^He.*(/d+).*Demo$")这句里是是在^He的后面.*这里匹配最大化，而(d+)这里可以匹配最少的数字，像后面的数字7，所以后面的使7而不是1234567

非贪婪问题

import re
content = "Hello 1234567 World_This is a Regex Demo"
result = re.match("^He.*?(d+).*Demo$", content)
print(result)
print(result.group(1)) # group(1)就是把第一个括号里的内容打印出来
print(result.span()) # 输出匹配结果的范围

<_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
1234567
(0, 40)
# 为什么使1234567而不是7呢？
# result = re.match("^He.*?(d+).*Demo$", content).在^He的后面是.*?是非贪婪匹配，匹配最少的元素，而后面有个(d+)所以在这里停止了，所以输出的是1234567

转义

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

None

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

<_sre.SRE_Match object; span=(0, 14), match='price is $5.00'>

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

re.search

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

import re
content ="Extra strings Hello 1234567 World_This is a Regex Demo Extra strings"
result = re.search("Hello.*?(d+).*?strings", content)
print(result)

<_sre.SRE_Match object; span=(14, 68), match='Hello 1234567 World_This is a Regex Demo Extra st>

总结：为匹配方便，能用哪个search就不用match

re.findall

搜索字符串，以列表形式返回全部能匹配的字符串。

string="猪  狗  鸡  鸭"

#当正则表达式中有两个括号时，其输出是一个list 中包含2个 tuple,从输出的结果可以看出，有两个元组，每一个元组中有两个字符串 : 其中第一个字符串"猪 狗"是最外面的括号输出的结果，第二个是里面括号(/w+)输出的结果 "猪", 第二个元组是  第二次匹配的结果 -- 详解同第一次匹配。
regex=re.compile("((w+)s+w+)")
print(regex.findall(string))

#正则表达式中有一个括号时,其输出的内容就是括号匹配到的内容，而不是整个表达式所匹配到的结果,但是整个正则表达式执行了只不过只输出括号匹配到的内容, 在第一次匹配时跟上述没有括号时一样，匹配到 "猪 狗" ,只不过只输出(/w+)匹配     到的结果 即"猪",第二次匹配同理从"鸡" 开始，匹配到"鸡 鸭",但是还是只是输出"鸡"
regex1=re.compile("(w+)s+w+")
print(regex1.findall(string))

#正则表达式中当没有括号时，就是正常匹配，在本例中"/w+/s+/w+"第一次匹配到的字符为"猪 狗",由于是贪婪模式会继续匹配,第二次从"鸡"开始匹配匹配到的结果为字符串"鸡 鸭"
regex2=re.compile("w+s+w+")
print(regex2.findall(string))

[('猪  狗', '猪'), ('鸡  鸭', '鸡')]
['猪', '鸡']
['猪  狗', '鸡  鸭']

re.sub

替换字符串中每一个匹配的子串后返回替换后的字符串。

import re

content = "Extra things Hello 1234567 World_This is a Regex Demo"
result = re.sub('d+','7654321',content)
print(result)

Extra things Hello 7654321 World_This is a Regex Demo

如果要替换的字符串是原字符串本身呢？或者包含圆字符串呢？ 

import re

content = "Extra things Hello 1234567 World_This is a Regex Demo"
result = re.sub('(d+)',r'1 7654321',content)    #"1"是一个转义的字符，为了要保证他的原生的字符，所以在前面加了一个r
print(result)

Extra things Hello 1234567 7654321 World_This is a Regex Demo

re.compile

将一个正则表达式编译成正则对象，以便复用该匹配模式