Python入门【原生字符串、边界字符、search函数、re模块中其他常用的函数、贪婪模式和非贪婪模式、择一匹配（|）的使用、分组】(三十)

👏作者简介：大家好，我是爱敲代码的小王，CSDN博客博主,Python小白
📕系列专栏：python入门到实战、Python爬虫开发、Python办公自动化、Python数据分析、Python前后端开发
📧如果文章知识点有错误的地方，请指正！和大家一起学习，一起进步👀
🔥如果感觉博主的文章还不错的话，请👍三连支持👍一下博主哦
🍂博主正在努力完成2023计划中：以梦为马，扬帆起航，2023追梦人

🔥🔥🔥 python入门到实战专栏：从入门到实战

🔥🔥🔥 Python爬虫开发专栏：从入门到实战

🔥🔥🔥 Python办公自动化专栏：从入门到实战

🔥🔥🔥 Python数据分析专栏：从入门到实战

🔥🔥🔥 Python前后端开发专栏：从入门到实战

原生字符串

边界字符

search函数

择一匹配（|）的使用

分组

re模块中其他常用的函数

sub和subn搜索与替换

compile 函数

findall 函数

finditer函数

split函数

贪婪模式和非贪婪模式

原生字符串

和大多数编程语言相同，正则表达式里使用“\”作为转义字符，这就可以能造成反斜杠困扰。

【示例】“\”作为转义字符

sxiao = 'c:\\a\\b\\c'
print(sxiao )

sxiao = '\n123'
print(sxiao )

sxiao = '\\n123'
print(sxiao )

假如你需要匹配文本中的字符“\”，那么使用编程语言表示的正则表达式里将需要4个反斜杠“\\”：前面两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。

Python里的原生字符串很好地解决了这个问题，使用Python的r前缀。例如匹配一个数字的“\d”可以写成r“\d”。有了原生字符串，再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。

【示例】Python中的r前缀的使用

import re
sxiao = r'\n123'
print(sxiao )

#目标字符串
sxiao = '\\n123'
pattern = '\\n\d{3}'
print(re.match(pattern,sxiao)) #返回None

#如果想匹配两个反斜杠需要使用两个反斜杠作为转义,即正则中要写四个反斜杠
pattern = '\\\\n\d{3}'
print(re.match(pattern,sxiao))

#使用原生字符串r比较方便
pattern = r'\\n\d{3}'
print(re.match(pattern,sxiao))

边界字符

注意：

1、^与[ ^m ] 中的“^”的含义并不相同，后者“^”表示“除了….”的意思

【示例】匹配符$的使用

import re
#匹配qq邮箱， 5-10位
print('未限制结尾'.center(30,'-'))
pattern = '[\d]{5,10}@qq.com'
print('正确的邮箱匹配结果：\n',re.match(pattern,'2423@qq.com'))
print('不正确的邮箱匹配结果：\n',re.match(pattern,'2423@qq.comabc'))
print('限制结尾'.center(30,'-'))
pattern = '[1-9]\d{4,9}@qq.com$'
print('正确的邮箱匹配结果：\n',re.match(pattern,'2423@qq.com'))
print('不正确的邮箱匹配结果：\n',re.match(pattern,'2423@qq.comabc'))

【示例】匹配符^的使用

import re
sxiao='hello python'
pattern=r'^hello.*'
print('匹配字符串hello python的结果：\n',re.match(pattern,sxiao))

sxiao='hepython'
pattern=r'^hello.*'
print('匹配字符串hepython的结果：\n',re.match(pattern,sxiao))

【示例】\b 匹配单词边界

pattern = r'.*\bab'
#ab左边界的情况
vxiao = re.match(pattern,'123 abr')
print(vxiao )
pattern = r'.*ab\b'

#ab为右边界的情况
vxiao = re.match(pattern,'wab')
print(vxiao )

【示例】\B 匹配非单词边界

#ab不为左边界
pattern = r'.*\Bab'
vxiao = re.match(pattern,'123 abr')
print(vxiao)

#ab不为右边界
pattern = r'.*ab\B'
vxiao= re.match(pattern,'wab')
print(vxiao)

search函数

search在一个字符串中搜索满足文本模式的字符串。

语法格式如下：

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

函数参数与match类似

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。如下表列出正则表达式修饰符 - 可选标志

【示例】search函数的使用

import re
mxiao=re.search('abc','abcdefg')
print(mxiao)
print(mxiao.group())

match与search的区别

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

【示例】match方法与search方法的使用对比

import re
#进行文本模式匹配，匹配失败，match方法返回None
mxiao=re.match('love','I love you')
if mxiaois not None:
    print(mxiao.group())
print('match运行结果：',mxiao)

#进行文本模式搜索，
mxiao=re.search('love','I love you')
if mxiaois not None:
    print(mxiao.group())
print('search的运行结果：',mxiao)

择一匹配（|）的使用

search方法搜索一个字符串，要想搜索多个字符串，如搜索aa、bb 和cc，最简单的方法是在文本模式字符串中使用择一匹配符号（|)。择一匹配符号和逻辑或类似，只要满足任何一个，就算匹配成功。

【示例】择一匹配符号（|）的使用

import re
sxiao='aa|bb|cc'
#match进行匹配
mxiao=re.match(sxiao,'aa')   #aa满足要求，匹配成功
print(mxiao.group())

mxiao=re.match(sxiao,'bb')   #bb满足要求，匹配成功
print(mxiao.group())

#search查找
mxiao=re.search(sxiao,'Where is cc')
print(mxiao.group())

【示例】匹配0-100之间所有的数字

import re
pattern = '[1-9]?\d$|100$'
print(re.match(pattern,'0'))
print(re.match(pattern,'10'))
print(re.match(pattern,'100'))
print(re.match(pattern,'99'))
print(re.match(pattern,'200'))

如果待匹配的字符串中，某些字符可以有多个选择，就需要使用字符集（[]），也就是一对中括号括起来的字符串。例如，[xyz]表示 x、y、z三个字符可以取其中任何一个，相当于“x|y|z”，所以对单个字符使用或关系时，字符集和择一匹配符的效果是一样的。

示例如下：

【示例】字符集（[]）和择一匹配符(|)完成相同的效果

import  re
mxiao=re.match('[xyz]','x')  #匹配成功
print(mxiao.group())

mxiao=re.match('x|y|z','x')  #匹配成功
print(mxiao.group())

【示例】字符集（[]）和择一匹配符(|)的用法，及它们的差异

import re

#匹配以第1个字母是a或者b，第2个字母是c或者d，如ac、bc、ad、bd
mxiao =re.match('[ab][cd]','aceg')
print(mxiao)

#匹配以ab开头，第3个字母是c或者d，如abc、abd
mxiao =re.match('ab[cd]','abcd')
print(mxiao)

#匹配ab或者cd
mxiao =re.match('ab|cd','cd')
print(mxiao)

分组

如果一个模式字符串中有用一对圆括号括起来的部分，那么这部分就会作为一组，可以通过group方法的参数获取指定的组匹配的字符串。当然，如果模式字符串中没有任何用圆括号括起来的部分，那么就不会对待匹配的字符串进行分组。

【示例】匹配座机号码

pattern = r'(\d+)-(\d{5,8}$)'
vxiao = re.match(pattern,'010-66668888')
print(vxiao)
print(vxiao.group())
print(vxiao.group(1))
print(vxiao.group(2))
print(vxiao.groups())
print(vxiao.groups()[0])
print(vxiao.groups()[1])

【示例】\num 的使用

import re

#匹配合法的网页标签
sxiao = '<html><title>我是标题</title></html>'
#匹配不合法的网页标签
ssxiao = '<html><title>我是标题</html></title>'
#优化前
pattern = r'<.+><.+>.+</.+></.+>'
print(re.match(pattern,sxiao))
print(re.match(pattern,ssxiao))

#优化后 可以使用分组 \2 表示引用第2个分组 \1表示
引用第1个分组
pattern = r'<(.+)><(.+)>.+</\2></\1>'
print(re.match(pattern,sxiao))
print(re.match(pattern,ssxiao))

【示例】?P (?P=起好的别名)

sxiao = '<html><h1>我是一号字体</h1></html>'
# pattern = r'<(.+)><(.+)>.+</\2></\1>'
#如果分组比较多的话，数起来比较麻烦，可以使用起别名的方法?P<要起的名字> 以及使用别名(?P=之前起的别名)
pattern = r'<(?P<key1>.+)><(?P<key2>.+)>.+</(?P=key2)></(?P=key1)>'
vxiao = re.match(pattern,sxiao)
print(vxiao )

使用分组要了解如下几点：

1、只有圆括号括起来的部分才算一组，如果模式字符串中既有圆括号括起来的部分，也有没有被圆括号括起来的部分，那么只会将被圆括号括起来的部分算作一组，其它的部分忽略。

2、用group方法获取指定组的值时，组从1开始，也就是说，group(1)获取第1组的值，group(2)获取第2组的值，以此类推。

3、groups方法用于获取所有组的值，以元组形式返回。所以除了使用group(1)获取第1组的值外，还可以使用groups()[0]获取第1组的值。获取第2组以及其它组的值的方式类似。

re模块中其他常用的函数

sub和subn搜索与替换

sub函数和subn函数用于实现搜索和替换功能。这两个函数的功能几乎完全相同，都是将某个字符串中所有匹配正则表达式的部分替换成其他字符串。用来替换的部分可能是一个字符串，也可以是一个函数，该函数返回一个用来替换的字符串。sub函数返回替换后的结果，subn函数返回一个元组，元组的第1个元素是替换后的结果，第2个元素是替换的总数。

语法格式如下：

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

参数	描述
pattern	匹配的正则表达式
repl	替换的字符串，也可为一个函数
string	要被查找替换的原始字符串。
count	模式匹配后替换的最大次数，默认 0 表示替换所有的匹配

【示例】sub和subn方法的使用

import re
phone = "2004-959-559 # 这是一个国外电话号码"

# 删除字符串中的 Python注释
numtong = re.sub(r'#.*$', "", phone)
print("电话号码是: ", numtong )

# 删除非数字(-)的字符串
numtong = re.sub(r'\D', "", phone)
print("电话号码是 : ", numtong )

#subn函数的使用
result=re.subn(r'\D', "", phone)
print(result)

print('替换的结果：',result[0])
print('替换的次数：',result[1])

compile 函数

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。语法格式为：

 re.compile(pattern[, flags])

参数	描述
pattern	一个字符串形式的正则表达式
flags	可选，表示匹配模式，比如忽略大小写，多行模式等，

【示例】compile 函数的使用

import re

sxiao='first123 line'
regex=re.compile(r'\w+') #匹配至少一个字母或数字
mtong=regex.match(sxiao)
print(mtong.group())

# s 的开头是 "f", 但正则中限制了开始为 i 所以匹配失败
regex = re.compile("^i\w+")
print(regex.match(sxiao))

findall 函数

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。语法格式如下：

findall(pattern, string, flags=0)

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。如下表列出正则表达式修饰符 - 可选标志

【示例】findall 函数的使用

import re
pattern=r'\w+'
sxiao='first 1 second 2 third 3'
otong=re.findall(pattern,sxiao)
print(otong)

注意：

match 和 search 是匹配一次 findall 匹配所有

finditer函数

和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

【示例】finditer函数的使用

pattern=r'\w+'
sxiao='first 1 second 2 third 3'
otong=re.finditer(pattern,sxiao)
print(otong)
for i in otong:
    print(i.group())

split函数

split函数用于根据正则表达式分隔字符串，也就是说，将字符串与模式匹配的子字符串都作为分隔符来分隔这个字符串。split函数返回一个列表形式的分隔结果，每一个列表元素都是分隔的子字符串。

语法格式如下：

re.split(pattern, string[, maxsplit=0,flags=0])

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
maxsplit	分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

【示例】split函数的使用

import re
stong='first 11 second 22 third 33'
#按数字切分
print(re.split(r'\d+',stong))
# maxsplit 参数限定分隔的次数，这里限定为1，也就是只分隔一次
print(re.split(r'\d+',stong,1))

贪婪模式和非贪婪模式

贪婪模式指Python里数量词默认是贪婪的，总是尝试匹配尽可能多的字符。非贪婪模式与贪婪相反，总是尝试匹配尽可能少的字符，可以使用"*"，"?"，"+"，"{m,n}"后面加上？，使贪婪变成非贪婪。

【示例】贪婪模式，.+中的'.'会尽量多的匹配

vtong = re.match(r'(.+)(\d+-\d+-\d+)','This is my tel:133-1234-1234')

print('----------贪婪模式---------')
print(vtong .group(1))
print(vtong .group(2))

print('----------非贪婪模式---------')
vtong = re.match(r'(.+?)(\d+-\d+-\d+)','This is my tel:133-1234-1234')
print(vtong .group(1))
print(vtong .group(2))

【示例】贪婪模式非贪婪模式测试

print('贪婪模式')
vtong= re.match(r'abc(\d+)','abc123')
print(vtong.group(1))

#非贪婪模式
print('非贪婪模式')
vtong= re.match(r'abc(\d+?)','abc123')
print(vtong.group(1))