python【正则表达式】

正则表达式

1.正则的作用

正则表达式式一种可以让复杂的字符串变得简单的工具。

写正则表达式的时候就是用正则符号来描述字符串规则。

2.正则语法

需要导入模块

from re import fullmatch, findall, search

2.1.第一类：匹配类符号

1）普通字符—在正则表达式中表式符号本身的符号

result = fullmatch(r'abc', 'abc')
print(result)  # <re.Match object; span=(0, 3), match='abc'>

2）.（点） —匹配任意一个字符

result = fullmatch(r'.bc', 'wbc')  # 第一位任意字符都可以，第二位和第三位必须是bc否则为空
print(result)  # <re.Match object; span=(0, 3), match='wbc'>
result = fullmatch(r'.bc', 'wcc')
print(result)  # None

3）\d — 匹配任意一个数字字符

result = fullmatch(r'\d\dabc', '88abc')  # abc前面任意两个数字都可以
print(result)  # <re.Match object; span=(0, 5), match='88abc'>

4）\s —— 匹配任意一个空白字符

空白字符：空格(‘’)、换行(‘\n’)、水平制表符(‘\t’)

result = fullmatch(r'123\sabc', '123 abc')
result1 = fullmatch(r'123\sabc', '123\tabc')

5）\w — 匹配任意一个字母、数字、下划线或者中文

result11 = fullmatch(r'abc\w123', 'abcT123')
result12 = fullmatch(r'abc\w123', 'abc8123')
result2 = fullmatch(r'abc\w123', 'abc_123')
result3 = fullmatch(r'abc\w123', 'abc我123')

6）\D、\S、\W —— 分布和\d、\s、\w的功能相反

\D —— 除了数字的任意字符

result4 = fullmatch(r'abc\D123', 'abcw123')
result5 = fullmatch(r'abc\D123', 'abc8123')  # None

\S —— 除了空白字符的任意字符

result41 = fullmatch(r'abc\S123', 'abc1123')
result51 = fullmatch(r'abc\SD123', 'abc 123')  # None

\W —— 除了字母，数字，下划线和中文的任意字符

result42 = fullmatch(r'abc\W123', 'abc*123')
result52 = fullmatch(r'abc\W123', 'abc_123')  # None

注意：如果字符中间是tab键，不可以，因为只能匹配任意一个字符，tab是四个。

7）[字符集] —— 匹配在字符集中的任意一个字符

[abc]  —— 匹配a或者b或者c
[abc\d] —— 匹配a或者b或者c或者任意数字：[abc0123456789]
[0-9] —— 匹配字符0到9中任意一个字符
[a-z] —— 匹配任意一个小写字母
[A-Z] —— 匹配任意一个大写字母
[a-z%] —— 匹配任意一个小写字母或者%
[a-zA-Z]  —— 匹配任意一个字母
[a-zA-Z\d]  —— 匹配任意一个字母或者数字
[\u4e00-\u9fa5] —— 匹配任意一个中文

result6 = fullmatch(r'abc[你好hello]123', 'abc你123')
print(result6)  # <re.Match object; span=(0, 7), match='abc你123'>result33 = fullmatch(r'abc[\u4e00-\u9fa5]123', 'abc婷123')
print(result33)

8)[^字符串] —— 匹配不在字符集中的任意一个字符

result71 = fullmatch(r'abc[^MN]123', 'abca123')  # 除了MN的字符，其它都可以
result72 = fullmatch(r'abc[^MN]123', 'abcM123')  # None

2.2 第二类符号：匹配次数符号

匹配类符号 匹配次数

1) * —— 任意次数（0次或者1次或者多次）

a*   —— a出现任意多次
\d*  —— 任意多个任意数字
[abc]*  —— abc中任意一个字符可以出现任意多次

result81 = fullmatch(r'1a*2', '1aaaaaaa2')
result82 = fullmatch(r'M\d*N', 'M1234567890N')
result83 = fullmatch(r'M[3-9]*N', 'M1234567890N')

2） + —— 一次或者多次（至少1次）

result86 = fullmatch(r'1a+2', '1aaa2')

3） ？ —— 0次或者1次

result84 = fullmatch(r'1a?2', '1aa2')  # none
result85 = fullmatch(r'1a?2', '1a2')

4) {}

{N}  —— N次
{M,N}  —— M到N次
{M,}  —— 至少M次
{,N} —— 最多N次

result8 = fullmatch(r'1a{3}2', '1aaa2')  # a出现3次
result87 = fullmatch(r'1a{3,6}2', '1aaaa2')  # a出现3到6次都可以

# 练习：写一个正则表达式，可以匹配任意一个除了0的整数。
# 合法：233、+234、-7283、100、-2000
# 不合法：0、0002、2.23
result9 = fullmatch(r'[-+]?[1-9]\d*', '0.123')
print(result9)

5）贪婪和非贪婪模式

1.在匹配次数不确定的时候，如果有多种次数都可以匹配成功，贪婪取最多的那个次数，非贪婪取最少的那个次数。
2.默认是贪婪模式·
3.贪婪模式：+、？、*、{M，N}、{M，}、{，N}
非贪婪模式：+？、？？、*？、{M，N}？、{M，}?、{，N}?

result10 = search(r'a.{3,5}b', 'a123b')  # 匹配字符串中第一个满足正则表达式,就是取三个
print(result10)

# 'ahhhhb','ahhhhbyyb','ahhhhbyybuuub'
result121 = search(r'a.+b', 'dhwahhhhbyybuuubvxgdfs')
print(result121)  # 'ahhhhbyybuuub'
# 非贪婪,就是在正常的写法后面加一个？
result122 = search(r'a.+?b', 'dhwahhhhbyybuuubvxgdfs')
print(result122)  # 'ahhhhb'

# 练习：使用正则提取top250中每个电影的详情页地址
import requests
from re import findallheaders = {'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/111.0.0.0 ''Safari/537.36 '
}
response = requests.get('https://movie.douban.com/top250?start=0&filter=', headers=headers)
result = findall(r'<a href="(https://movie.douban.com/subject/.*?/)" ', response.text)
print(result)
#方法2
response = requests.get('https://movie.douban.com/top250?start=0&filter=', headers=headers)
result = list(set(findall(r'https://movie.douban.com/subject/.*?/ ', response.text))) 
print(result)

3.分组和分支

1)分组 —— ()

正则表达式中可以用()将部分内容括起来表示一个整体；括号括起来的部分就是一个分组
a.整体操作的时候需要分组
b.重复匹配 —— 正则中可以通过\M来重复它前面第M个分组匹配的结果
c.捕获 —— 提取分组匹配到的结果(捕获分为自动捕获(findall)和手动捕获)

1.整体操作

# 整体操作
# '23M'
result23 = fullmatch(r'(\d\d[A-Z])+', '45T45H65F56G90D')
print(result23)

2.重复匹配

# 重复匹配；\1是指的是重复前面第一个括号
#案例： '90k90' , '80u80','99u99'
result32 = fullmatch(r'(\d\d)[A-Z]\1', '90K90')
print(result32)  # <re.Match object; span=(0, 5), match='90K90'>
# \2是指的是重复第2个括号
result3211 = fullmatch(r'(\d{3})([A-Z]{2})=\2\1', '999LO=LO999')
print(result3211)  # <re.Match object; span=(0, 11), match='999LO=LO999'>
#案例2： 提取中文后的数字
# findall在正则表达式中有分组的时候，会自动提取正则匹配结果中分组匹配到的内容
message = 'hfuuf你好335556432jfigh89和2470'
result99 = findall(r'[\u4e00-\u9fa5](\d+)', message)
print(result99)  # ['335556432', '2470']
#案例3：提取身高的数据
message = '我是小明，今年18岁,身高180cm,体重70kg'
result = search(r'身高(\d+)cm,体重(\d+)kg', message)

2)匹配对象.group(N) —— 获取匹配结果中指定的分组匹配到的内容

print(result)  # <re.Match object; span=(11, 25), match='身高180cm,体重70kg'>
print(result.group())  # 身高180cm,体重70kg
print(result.group(1), result.group(2))  # 180 70

3) 分支 —— |

正则1|正则2|正则3|....  —— 先用正则1进行匹配，匹配成功直接成功；匹配失败用正则2进行匹配...

result = fullmatch('\d{3}|[a-z]{2}', 'mn')
print(result)  # <re.Match object; span=(0, 2), match='mn'>result = fullmatch(r'abc\d\d|abc[A-Z]{2}', 'abc23')
print(result)  # <re.Match object; span=(0, 5), match='abc23'>result = fullmatch(r'abc(\d\d|[A-Z]{2})', 'abcLL')
print(result)  # <re.Match object; span=(0, 5), match='abcLL'>

4.转义符号

转义符号：在本身具有特殊功能或者特殊意义的符号前加,让特殊符号变成普通意思。

# 案例：匹配整数部分和小数部分都是两位数的小数
result = fullmatch(r'[1-9]\d\.\d\d', '23.45')
print(result) #<re.Match object; span=(0, 5), match='23.45'># 案例：需要求两个数的和
result = fullmatch(r'\d\+\d','3+4')
print(result)  #<re.Match object; span=(0, 3), match='3+4'># 案例：打印’（amd）‘
result = fullmatch(r'\([a-z]{3}\)','(jsk)')
print(result)  #<re.Match object; span=(0, 5), match='(jsk)'># 注意：单独存在有特殊意义的符号，在[]中它的功能会自动消失
# 适用于 + . ? * $
result = fullmatch(r'\d[+]\d','3+4')
print(result) #<re.Match object; span=(0, 3), match='3+4'>

5.re模板

re模块 —— 提供了python中所有和正则相关的函数。

1. fullmatch(正则表达式,字符串) —— 用整个字符串判断是否满足正则表达式所描述的规则，匹配成功返回匹配对象，匹配失败None
2. findall(正则表达式,字符串) —— 获取字符串所有满足正则表达式的子串，默认返回一个列表，列表中匹配的元素是所有子串；存在自动捕获；
3. search(正则表达式,字符串) —— 匹配字符串中第一个满足正则表达式的子串,匹配成功返回匹配对象，匹配失败返回空
4. split(正则表达式,字符串) —— 将字符串中 所有满足正则的子串作为切割点进行切割
5. split(正则表达式,字符串,N) —— 将字符串中前N个满足正则的子串作为切割点进行切割
6. sub(正则表达式,字符串1,字符串2) —— 将字符串2中所有满足正则的子串都替换成字符串1
7. sub(正则表达式,字符串1,字符串2,N)
8. finditer(正则表达式,字符串) —— 获取字符串中所有满足正则的子串，返回一个迭代器，迭代器中的元素是匹配对象
9. match(正则表达式,字符串) —— 匹配字符串开头

str1 = '技术7d3eee5eee7ef7njk9你减肥胶囊7'
print(str1.split('7'))  # ['技术', 'd3eee5eee', 'ef', 'njk9你减肥胶囊', '']str1 = '技术7d3eee5eee7ef7njk9你减肥胶囊7'
print(split(r'\d+', str1, 2))  # ['技术', 'd', 'eee5eee7ef7njk9你减肥胶囊7']str1 = '技术7d3eee5eee7ef7njk9你减肥胶囊7'
print(sub(r'\d', '+', str1))  #技术+d+eee+eee+ef+njk+你减肥胶囊+message = '妈的，sb,西八，都打起来了你还在打野！操！fuck'
print(sub(r'(?i)妈的|sb|西八|操|f\s*u\s*c\s*k|艹','*',message)) #*，*,*，都打起来了你还在打野！*！*str1 = '技术7d3eee5eee7ef7njk9你减肥胶囊7'
result = finditer(r'\d+', str1)
print(list(result)) #<re.Match object; span=(15, 16), match='7'>, <re.Match object; span=(19, 20), match='9'>, <re.Match object; span=(25, 26), match='7'>]print(fullmatch(r'\d{3}', '234'))
print(match(r'\d{3}', '234Ihs你好'))

6.参数

1)忽略大小写:(?i)

print(fullmatch(r'(?i)abc', 'abc'))
print(fullmatch(r'(?i)abc', 'Abc'))
print(fullmatch(r'(?i)abc', 'ABc'))
print(fullmatch(r'(?i)abc', 'AbC'))

2)单行匹配:(?s)

多行匹配(默认)：.(点) 不能和换行符(\n)进行匹配

单行匹配:.(点)可以和换行符进行匹配

print(fullmatch(r'abc.123','abc0123'))  # None
# print(fullmatch(r'abc.123','abc\n123'))
print(fullmatch(r'(?s)abc.123','abc\n123'))  # <re.Match object; span=(0, 7), match='abc\n123

举例：

'''
# 输入多行
name:'student
——小张'
'''
message = """name:"student
wqe小张"
"""
result = findall(r'(?s)name:"(.+)"',message)
print(result) #['student\nwqe小张']