正则表达式概念以及基础应用_正则表达式查找返回的结果是什么数据类型-CSDN博客

本文链接：https://blog.csdn.net/python20180218/article/details/90510029

页面解析和数据提取

一般来讲对我们而言，需要抓取的是某个网站或者某个应用的内容，提取有用的价值。内容一般分为两部分，非结构化的数据和结构化的数据。
非结构化数据：先有数据，再有结构，
结构化数据：先有结构、再有数据
不同类型的数据，我们需要采用不同的方式来处理。

非结构化的数据处理
文本、电话号码、邮箱地址
"^((13[0-9])|(14[5|7])|(15([0-3]|[5-9]))|(18[0,5-9]))\d{8} $KaTeX parse error: Can't use function '\.' in math mode at position 34: …[a-zA-Z0-9_-]+(\̲.̲[a-zA-Z0-9_-]+)…$

HTML 文件
正则表达式
XPath
CSS选择器
结构化的数据处理
JSON 文件
JSON Path
转化成Python类型进行操作（json类）
XML 文件
转化成Python类型（xmltodict）
XPath
CSS选择器
正则表达式

为什么要学正则表达式

实际上爬虫一共就四个主要步骤：
1.明确目标 (要知道你准备在哪个范围或者网站去搜索)
2.爬 (将所有的网站的内容全部爬下来)
3.取 (去掉对我们没用处的数据)
4.处理数据（按照我们想要的方式存储和使用）

我们在之前的案例里实际上省略了第3步，也就是"取"的步骤。因为我们down下了的数据是全部的网页，这些数据很庞大并且很混乱，大部分的东西使我们不关心的，因此我们需要将之按我们的需要过滤和匹配出来。
那么对于文本的过滤或者规则的匹配，最强大的就是正则表达式，是Python爬虫世界里必不可少的神兵利器。

什么是正则表达式

正则表达式，又称规则表达式，通常被用来检索、替换那些符合某个模式(规则)的文本。
正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。

给定一个正则表达式和另一个字符串，我们可以达到如下的目的：
给定的字符串是否符合正则表达式的过滤逻辑（“匹配”）；
通过正则表达式，从文本字符串中获取我们想要的特定部分（“过滤”）。

正则表达式是由普通字符和特殊字符（元字符）组成的文字模式
正则表达式入门小例子
正则表达式测试网址

我们想要找一篇英文文献里面的所有we的单词
文本：we are well Welcome
正则表达式：we 匹配所有的含有we的但是包括well welcome
正则表达式：\bwe\b 只匹配了we
\b是正则表达式的特殊字符，称为元字符，匹配的是单词的开始和结束，也就是单词的分界处。
例子：

import re
#首先创建pattern对象
pattern1=re.compile("we")#打印出所有的we

# #使用findall匹配信息,匹配到所有的we，返回一个列表。
result1=pattern1.findall("we are working how are you i am well thinks and you Welcome")
print(result1)


import re
#首先创建pattern对象
pattern2=re.compile(r"\bwe\b")#\b表示以什么开头以什么结尾，打印出来是单词we
# #使用findall匹配信息,匹配到所有的we，返回一个列表。
result2=pattern2.findall("we are working how are you i am well thinks and you Welcome")
print(result2)

Python 的 re 模块

在 Python 中，我们可以使用内置的 re 模块来使用正则表达式。
有一点需要特别注意的是，正则表达式使用对特殊字符进行转义，所以如果我们要使用原始字符串，只需加一个 r 前缀，示例：

#使用的模块是re
#只打印除了\C，因为\a\b是元字符，没有打印出来
print("\a\b\c")#\c
#想打印出元字符，前面加r
print(r"\a\b\c")#\a\b\c
#对\进行转义，打印出\本身
print("\\")
#这样也可以被原始字符串打印出来
print("\\a\\b\c")
#加r防止字符被转义。

re 模块的一般使用步骤如下：
1.使用 compile() 函数将正则表达式的字符串形式编译为一个 Pattern 对象
2.通过 Pattern 对象提供的一系列方法对文本进行匹配查找，获得匹配结果，一个 Match 对象。
3.最后使用 Match 对象提供的属性和方法获得信息，根据需要进行其他的操作

compile 函数
compile 函数用于编译正则表达式，生成一个 Pattern 对象，它的一般使用形式如下：

Pattern 对象的一些常用方法主要有：
match 方法：从起始位置开始查找，一次匹配
search 方法：从任何位置开始查找，一次匹配
findall 方法：全部匹配，返回列表
finditer 方法：全部匹配，返回迭代器
split 方法：分割字符串，返回列表
sub 方法：替换

findall 方法

我们需要搜索整个字符串，获得所有匹配的结果，使用的是findall()方法
findall 方法的使用形式如下：
findall(string[, pos[, endpos]])
其中，string 是待匹配的字符串，pos 和 endpos 是可选参数，指定字符串的起始和终点位置，默认值分别是 0 和 len (字符串长度)。
findall 以列表形式返回全部能匹配的子串，如果没有匹配，则返回一个空列表。

常见元字符：

前面提到的元字符\b表示匹配单词的开始和结束。引出其他元字符
元字符含义

. 匹配除换行符以外的任意一个字符
^ 匹配行首
$ 匹配行尾
？重复匹配0次或1次

重复匹配0次或更多次

重复匹配1次或更多次
{n,} 重复n次或更多次
{n,m} 重复n~m次
[a-z] 任意字符，匹配a-z的所有字符
[abc] a/b/c中的任意一个字符
{n} 重复n次
\b 匹配单词的开始和结束
\d 匹配数字
\w 匹配字母，数字，下划线
\s 匹配任意空白，包括空格，制表符（Tab）,换行符
\W 匹配任意不是字母，数字，下划线的字符
\S 匹配任意不是空白符的字符
\D 匹配任意非数字的字符
\B 匹配不是单词开始和结束的位置
[^a] 匹配除了a以外的任意字符
[^(123|abc)] 匹配除了123或者abc这几个字符以外的任意字符

举例：

import re

#创建一个pattern对象
pattern1=re.compile("\d")#匹配一个数字
result1=pattern1.findall("hello 123 like 520")
print(result1)#['1', '2', '3', '5', '2', '0']


pattern2=re.compile("\d+")#匹配多个数字，如果是多个数字，必须连续
result2=pattern2.findall("hello 123 like 520")
print(result2)#['123', '520']

pattern3=re.compile("\d{3,}")#匹配三哥或三个以上的连续数字。
result3=pattern3.findall("hello  12 1234 like 520")
print(result3)#['1234', '520']

pattern4=re.compile("\d{3}")#只连续匹配三次
result4=pattern4.findall("hello  12 1234 like 520")
print(result4)#['123', '520']

pattern5=re.compile("\d{1,2}")#可以匹配一次，也可匹配两次，以多的优先
result5=pattern5.findall("hello  12 1234 like 520")
print(result5)#['12', '12', '34', '52', '0']

pattern6=re.compile("[a-z]")#匹配所有的字母
result6=pattern6.findall("hello  12 1234 like 520")
print(result6)#['h', 'e', 'l', 'l', 'o', 'l', 'i', 'k', 'e']

pattern7=re.compile("[a-z]{5}",re.I)#匹配连续5次，a-z的字母,忽略大小写
result7=pattern7.findall("hello 123 234 66 4 2232 qTite like")
print(result7)#['hello', 'qTite']

pattern8=re.compile("\w",)#匹配数字字母下划线，一次或多次
result8=pattern8.findall("he#@l_lo    1_2_3   ")
print(result8)#['h', 'e', 'l', '_', 'l', 'o', '1', '_', '2', '_', '3']

pattern9=re.compile("\s+",)#匹配到一个或多个空白符
result9=pattern9.findall("he#@l_lo    1_2_3   ")
print(result9)

pattern10=re.compile("\W+")#匹配不是数字字母下划线：
result10=pattern10.findall("he#@l_lo    1_2_3   ")
print(result10)#['#@', '    ', '   ']

pattern11=re.compile("[\w\W]+")#匹配所有的字符
result11=pattern11.findall("he#@l_lo    1_2_3   ")
print(result11)#['a', 'ab', 'ab', 'abccab', 'abc']

pattern12=re.compile("[abc]+")#匹配a或b或c 一次或者多次，连续匹配
result12=pattern12.findall("he#@l_lo    1_2_3 a ab,abd,abccab, abc  ")
print(result12)

pattern13=re.compile("[^(123|abc)]+")#匹配不是123或abc的字符，一次或多次
result13=pattern13.findall("he#@l_lo    1_2_3 a ab,abd,abccab, abc  ")
print(result13)#['he#@l_lo    ', '_', '_', ' ', ' ', ',', 'd,', ', ', '  ']

pattern14=re.compile(".*")#匹配任以字符，除了换行
result14=pattern14.findall("he#@l_lo    1_2_3 a ab,abd,abccab,123 23 45 12345")
print(result14)#['he#@l_lo    1_2_3 a ab,abd,abccab,123 23 45 12345', '']

pattern15=re.compile("[a-z]{5}",re.I)#匹配连续5次，a-z的字母,忽略大小写
#之查找字符串在索引0,20之间范围的字符，要前不要后、就是前闭后开.
result15=pattern15.findall("Hello cd 123 asaadse 234 66 4 2232 quiteY",0,20)
print(result15)#['Hello', 'asaad']

match 方法

match 方法用于查找字符串的头部（也可以指定起始位置），它是一次匹配，只要找到了一个匹配的结果就返回，而不是查找所有匹配的结果。它的一般使用形式如下：
match(string[, pos[, endpos]])
其中，string 是待匹配的字符串，pos 和 endpos 是可选参数，指定字符串的起始和终点位置，默认值分别是 0 和 len (字符串长度)。因此，当你不指定 pos 和 endpos 时，match 方法默认匹配字符串的头部。
当匹配成功时，返回一个 Match 对象，如果没有匹配上，则返回 None。

import re

pattern1=re.compile("\d+")
#match从头开始匹配，只匹配一次，匹配不到返回None
result1=pattern1.match(" as 123 asd 43 ndg")
print(result1)#None

pattern2=re.compile("\d+")
#match匹配，从头开始匹配，匹配一次返回。返回的是match类型的数据。
result2=pattern2.match("123 asd 43 ndg")
print(result2)##span=(0, 3), match='123'   span是查找到的范围，前闭后开。match是匹配到的数据
print(result2.group())#提取匹配到的数据。后面有0和没有0效果是一样的
print(result2.group(0))#提取匹配到的数据。后面有0和没有0效果是一样的
print(result2.span())#(0, 3),#获取匹配的范围（开始和结束的位置），是一个元组。
print(result2.start())#获取匹配开始位置
print(result2.end())#获取匹配结束的位置

pattern3=re.compile("\d+")
#match匹配，从头开始匹配，匹配一次返回。返回的是match类型的数据。
#返回是none 匹配的位置一定得从数字开始。
result3=pattern3.match(" as 123 asd 43 ndg",2,10)
print(result3)#None

pattern4=re.compile("\d+")
#match匹配，从头开始匹配，匹配一次返回。返回的是match类型的数据。
# 匹配的位置一定得从数字开始。
result4=pattern4.match(" as 123 asd 43 ndg",5,10)
print(result4)#<_sre.SRE_Match object; span=(5, 7), match='23'>


pattern5=re.compile("([a-z]+) ([a-z]+)")
result5=pattern5.match("hello world wind will")
print(result5)
print(result5.group())
print(result5.group(0))#获取所有匹配的内容
print(result5.group(1))#获取第一个括号的内容
print(result5.group(2))#获取第二个括号的内容
print(result5.groups())#获取全部，得到一个元组

search 方法
search 方法用于查找字符串的任何位置，它也是一次匹配，只要找到了一个匹配的结果就返回，而不是查找所有匹配的结果，它的一般使用形式如下：
search(string[, pos[, endpos]])
其中，string 是待匹配的字符串，pos 和 endpos 是可选参数，指定字符串的起始和终点位置，默认值分别是 0 和 len (字符串长度)。
当匹配成功时，返回一个 Match 对象，如果没有匹配上，则返回 None。
让我们看看例子：

import re
pattern=re.compile("\d+")
#search是一次性皮匹配，从任意位置开始，返回的是match对象，
# 和match最大的不同就是开始位置不同、、没有查找到返回的是none
result=pattern.search("asd 12 34 we 45")
print(result)#<_sre.SRE_Match object; span=(4, 6), match='12'>
print(result.group())#12
print(result.start())#4
print(result.end())#6
print(result.span())#(4,6)

小总结：match和search的区别和联系：
区别：
match是从头开始匹配一次，而search是从任意位置开始匹配一次
联系：
两者都只匹配一次，返回的数据类型都是match数据类型。

finditer 方法

finditer 方法的行为跟 findall 的行为类似，也是搜索整个字符串，获得所有匹配的结果。但它返回一个顺序访问每一个匹配结果（Match 对象）的迭代器。
看看例子：

import re

pattern1=re.compile("\d+")
#finditer是全局查找，返回的是一个迭代器
result1_iter=pattern1.finditer("one135two456three786")
print(result1_iter)
#遍历迭代器，一个一个拿出我们想要的数据
for i in result1_iter:
    #返回的是match对象。
    print(i)
    #获取match对象中的内容
    print(i.group())
"""
列表和迭代器的区别：（findall和finditer的区别）
迭代器不占用内存，等到你想要的时候遍历获取即可。
列表占用大量内存，不使用的时候也会占用大量的内存
用文件夹压缩包举例
findall返回的是列表，finditer返回的是match数据类型的迭代器
"""

split 方法

split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：
split(string[, maxsplit])
其中，maxsplit 用于指定最大分割次数，不指定将全部分割。
看看例子：

import re

#把所有字母分开
pattern=re.compile(r"[\s\:\;\?]+")
#split是分隔符，以空格，分号，冒号，问号进行分割
result=pattern.split("12,ew;ads;54;79u:??ajkd : ww")
print(result)#['12,ew', 'ads', '54', '79u', 'ajkd', 'ww']

sub 方法

sub 方法用于替换。它的使用形式如下：
sub(repl, string[, count])
其中，repl 可以是字符串也可以是一个函数：
如果 repl 是字符串，则会使用 repl 去替换字符串每一个匹配的子串，并返回替换后的字符串，另外，repl 还可以使用 id 的形式来引用分组，但不能使用编号 0；
如果 repl 是函数，这个方法应当只接受一个参数（Match 对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。
count 用于指定最多替换次数，不指定时全部替换。

import re
#w 匹配狮子字母下划线
pattern=re.compile("(\w+) (\w+)")
str="i love you 520"
result=pattern.sub("you like",str)
print(result)#you like you like