from re import fullmatch,search,findall

1.什么是正则表达式

正则表达式是处理字符串的工具,通过不同的正则符号来描述字符串的规则

2.正则符号(正则表达式的语法)

1)普通字符

含义:
除了在正则中有特殊功能和特殊意义的符号意外的字符都算普通字符
普通字符代表字符本身

# 匹配一个字符中有三个字符：分别是'a','b','c'
re_str = r'abc'
result = fullmatch(re_str,'abc')
print(result)  # <re.Match object; span=(0, 3), match='abc'>
result = fullmatch(re_str,'abced')
print(result)  # None

2) . - 匹配任意一个字符

匹配一个字符串长度为3，第一个字符为'a',最后一个字符为'c',中间任意一个字符都可以

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

3）\w - 匹配一个数字、字母或者_(在ASCII码表中)

一个\w只能匹配一个字符
了解，不好用，用起来有问题

result = fullmatch(r'\w\wa','1sa')
print(result)  # <re.Match object; span=(0, 3), match='1sa'>

4) \d - 匹配任意一个数字字符

一个\d只能匹配一个字符

result = fullmatch(r'\da\d','2a3')
print(result)  # <re.Match object; span=(0, 3), match='2a3'>
result = fullmatch(r'\da\d...','2a3ej9')
print(result)  # <re.Match object; span=(0, 6), match='2a3ej9'>

5) \s - 匹配任意一个空白字符

空白字符：表示可以产生空白效果的字符，包括：空格、换行、制表符...

result = fullmatch(r'\da\s.\s.\s.','2a\ne\tj 9')
print(result)  # <re.Match object; span=(0, 8), match='2a\ne\tj 9'>

6) \大写字母

\D - 匹配非数字字符
\S - 匹配一个非空白字符

result = fullmatch(r'\D\S\S\S','OSDF')
print(result)  # <re.Match object; span=(0, 4), match='OSDF'>

7) [字符集] - 匹配字符集中出现的任意一个字符

注意：一个[]只能匹配一个字符
[abc] ：表示匹配'a'或者'b'或者'c'
[赵钱孙李] ：表示匹配赵钱孙李中的一个字符
[]中含有-（字符编码值递增）
[1-9] ：匹配1到9中任意一个
[a-zA-Z] : 匹配任意一个字母
[a-zA-Z\d] : 匹配任意一个字母数字
[\u4e00-\u9fa5] : 匹配任意一个中文

result = fullmatch(r'[135]ab','3ab')
print(result)  # <re.Match object; span=(0, 3), match='3ab'>
result = fullmatch(r'[1-5]ab','3ab')
print(result)  # <re.Match object; span=(0, 3), match='3ab'>

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

[^abc] : 匹配任意一个不是a,b,c的字符
[^2-8] : 匹配不是数字2到8的任意一个字符

result = fullmatch(r'[^1-5]ab','6ab')
print(result)  # <re.Match object; span=(0, 3), match='6ab'>

3.检测字符

所有的检测符号都不会影响字符串的长度

1) \b :检查是否是单词边界

单词边界：能够将两个单词隔开，且不会产生歧义的任意符号：如空白字符、标点符号、字符串开头和字符串结尾
匹配规则：先去掉\b对字符串进行匹配，如果匹配成功再检查\b所在的位置是否是单词边界
注意：\b只做判断，不代表字符

result = search(r'you \bare', 'you are dfs')
print(result)  # <re.Match object; span=(0, 7), match='you are'>
result = findall(r'. \b.', 'you are dfs')
print(result)  # ['u a', 'e d']

2) ^{在[]外面,检查}所在的位置是否是字符串开头

result = search(r'^[^a-z]ab', '1ab 5ab dfs')
print(result)  # <re.Match object; span=(0, 3), match='1ab'>
result = findall(r'^[^a-z]ab', '1ab 5ab dfs')
print(result)  # <re.Match object; span=(0, 3), match='1ab'>

3) $- 检查$ 所在的位置是否是字符串结尾

result = search(r'[^a-z]ab$', 'dljsdfiojfkfls1ab')
print(result)  # <re.Match object; span=(14, 17), match='1ab'>

4、控制次数的符号：字符符号

1). * - 匹配任意次（包括0次）

123a* - 123后面a可以出现任意次 123 123a 123aa 123aaa 123aaaa
123\d* - 123后面可以出现任意个数字 1234556444343 123 123458
123[mnxy9]* - 123,123m,123mn,123nm9,...

2). + - 匹配1次或多次

123a+ - 123a,123aa,123aaa,...

3). ? - 匹配0次或者1次

-?123 - -123 123

4). {}

{N} - 匹配N次
a{3} - aaa
\d{3} - 123 345 432 235 ...
{M,N} - 匹配M到N次(至少M次，最多N次)
a{1,3} - a aa aaa
{M,} - 匹配至少M次
{,N} - 匹配最多N次

5.贪婪和非贪婪

在匹配次数不确定的时候，会出现贪婪和非贪婪两种情况；默认情况都是贪婪的。

什么是贪婪：在能够匹配成功的前提下，匹配次数尽可能多
什么是非贪婪：在能够匹配成功的前提下，匹配次数尽可能少

在匹配次数后加？变成非贪婪

re_str = r'a.+'
print(search(re_str,'hsjsa==ejkx'))  # <re.Match object; span=(4, 11), match='a==ejkx'>
print(findall(re_str,'hsjsa==ejkx'))  # ['a==ejkx']
re_str = r'a\d+'
print(search(re_str,'hsjsa2334=a3=ea993jkx'))  # <re.Match object; span=(4, 9), match='a2334'>
print(findall(re_str,'hsjsa2334=a3=ea993jkx'))  # ['a2334', 'a3', 'a993']
re_str = r'a\d+?'
print(search(re_str,'hsjsa2334=a3=ea993jkx'))  # <re.Match object; span=(4, 6), match='a2'>
print(findall(re_str,'hsjsa2334=a3=ea993jkx'))  # ['a2', 'a3', 'a9']

6、分之与分组

1).分子： |

正则1|正则2 - 先让正则1去匹配，如果匹配成功就成功；如果匹配失败再让正则2去匹配
（正则1和正则2中只要有一个能匹配成功就行）

re_str = r'abc|123'
print(findall(re_str,'dl123ljvabcop123'))  # ['123', 'abc', '123']

2）.分组：() - 将括号里面的内容作为一个整体

1)整体操作

r'(\d\d|[A-Z]{2})abc' - 匹配一个字符串后面是abc，前面是两个数字或者两个大写字母
r'([a-z]\d){3}' - 一个字母加一个数字重复出现3次

2) 分组

a.分组截取：方便后面分段或者分情况取不同匹配结果
b.分组重复：在正则中用\X来重复前面第X个分组匹配到的内容
注意：\X的前面必须有这个分组

re_str = r'(\d{3})[a-z]{3}\1'
print(search(re_str,'sdf123123jva123d'))  # <re.Match object; span=(0, 9), match='123jva123'>
print(findall(re_str,'sdf123123jva123d'))  # ['123']

练习1：写一个正则表达式匹配一个字符串：abc的前面是两个数字或者两个大写字母

方法1：r'\d{2}|[A-Z]{2}abc'
方法2：r'(\d\d|[A-Z]{2})abc'

7.转义符号

1).加\

在正则中有特殊功能和特殊意义的符号前加\，让这个符号的特殊功能和意义消失

re_str = r'\d{3}\.[a-z]{2}'
print(search(re_str, 's123.df123jva123.de'))  # <re.Match object; span=(1, 7), match='123.df'>
print(findall(re_str, 's123.df123jva123.de'))  # ['123.df', '123.de']

2).加[]

在[]中有特殊意义的符号：a.^放在最开头 b.-放在两个字符之间
其它符号包括：.+?*$ 这些单独的符号在[]中都表示这个符号本身

re_str = r'\d{3}[.][a-z]{2}'
print(search(re_str, 's123.df123jva123.de'))  # <re.Match object; span=(1, 7), match='123.df'>

8.re模块

re模块是python提供的，专门针对正则表达式应用的相关函数

1）.compile(正则表达式) -> 将正则表达式转换成正则对象

re_obj = compile(r'\d{3}')
re_obj.fullmatch('123')

2）.字符串匹配

fullmatch(正则表达式，字符串) - 让正则表达式和字符串完全匹配
match(正则表达式，字符串) - 匹配字符串开头

以上两个方法的结果：匹配失败结果是None，匹配成功会返回对象

re_str = r'\d{3}'
print(fullmatch(re_str,'345'))   # <re.Match object; span=(0, 3), match='345'>
print(match(re_str,'23549794'))   # <re.Match object; span=(0, 3), match='235'>

3)匹配对象

result = match(r'(\d{3})(=)([a-z]{2})','234=amdrer44')
print(result) # <re.Match object; span=(0, 6), match='234=am'>

a.获取匹配到的字符串

匹配对象.group() - 获取整个正则表达式匹配到的字符串，结果是字符串
匹配对象.group(N) - 获取整个正则表达式中第N个分组匹配到的字符串

print(result.group())     # 234=am
print(result.group(3))     # am

b.获取匹配到的字符串在原字符串中的位置信息

匹配对象.span() -> 返回匹配结果在原字符串中的下标范围：[开始下标，结束下标)
匹配对象.span(N) -> 返回第N个分组匹配到的结果在原字符串中的下标范围：[开始下标，结束下标)

print(result.span())    # (0, 6)
print(result.span(2))     # (3, 4)

c.获取原字符串

匹配对象.string

print(result.string)   # 234=amdrer44

4).查找

1)search(正则表达式，字符串) - 在字符串中查找第一个满足正则表达式的子串，如果找到，结果是匹配对象，找不到结果是None
2)findall(正则表达式，字符串) - 获取字符串中所有满足正则表达式的子串，返回值是一个列表
注意：如果正则表达式中有分组，列表中的元素就是匹配结果只会取分组匹配到的内容
3)finditer(正则表达式，字符串) - 获取字符串中所有满足正则表达式的子串；返回值是一个迭代器，元素是匹配对象

result = search(r'(\d{3})(=)([a-z]{2})','234=amdrer44')
print(result)   # <re.Match object; span=(0, 6), match='234=am'>
result = findall(r'\d{3}[a-z]{2}','dsf4234fger3423434fewdf')
print(result)   # ['234fg', '434fe']
result = findall(r'(\d{3})[a-z]{2}','dsf4234fger3423434fewdf')
print(result)   # ['234', '434']
result = findall(r'(\d{3})([a-z]{2})','dsf4234fger3423434fewdf')
print(result)   # [('234', 'fg'), ('434', 'fe')]
result = finditer(r'(\d{3})([a-z]{2})','dsf4234fger3423434fewdf')
print(result)   # <callable_iterator object at 0x0000025604B5FFD0>
for x in result:
    print(x.group())   # 234fg    434fe

5).切割

split(正则表达式，字符串) - 将字符串中满足正则表达式的子串作为切割点对字符串进行切割

result = split(r'\d+','dluo390202nnvov902jl9j93i')
print(result)   # ['dluo', 'nnvov', 'jl', 'j', 'i']

6).替换

sub(正则表达式，字符串1，字符串2) - 将字符串2中所有满足正则表达式的子串都替换成字符串1

python正则表达式