day17-总结

正则表达式

from re import fullmatch, search, findall

1.什么是正则表达式

正则表达式是处理字符串的工具，通过不同的正则符号来描述字符串的规则
正则符号（语法）

匹配符号

1)普通字符：除了在正则中有特殊功能和特殊意义的符号以外的字符都是普通字符

普通字符：代表字符本身

fullmatch(正则表达式，字符串) - 查看字符串和正则表达式是否匹配，如果不匹配返回结果None

正则表达式：r'正则语法'

1).匹配一个字符串有三个字符，分别是'a', 'b', 'c'

re_str = r'abc'  #
result = fullmatch(re_str, 'abc')
print(result)

2) . - 匹配一个任意字符（一个 . 只能匹配一个字符）

匹配一个字符串长度是8，前三个是abc，中间两个点表示任意字符，后三个字符是123

re_str = r'abc..123'
result = fullmatch(re_str, 'abc21123')
print(result)

3).\w - 匹配一个数字、字母或者下划线_ （一个\w智能匹配一个字符）(在ASCII码表中)

匹配一个长度为4的字符串，第一个字符是数字、字母或者下划线_，后面的三个字符是'abc'

re_str = r'\wabc'
result = fullmatch(re_str, '_abc')
print(result)

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

匹配一个长度为5的字符串，前两个字符时任意数字，后面三个是任意字符

re_str = r'\d\d...'
result = fullmatch(re_str, '12l==')
print(result)

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

（space（）、enter、tab）

result = fullmatch(r'how\s\s\sare!', 'how \t\nare!')
print(result)

6）\大写字母

\D - 匹配除了数字字符以外的任意字符（非数字字符）
\S - 匹配非空白字符

re_str = r'\Dabc\S'
print(fullmatch(re_str, 'aabcs'))

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

注意：一个[]只能匹配一个字符

a.

[abc] - 匹配abc中任意一个字符
[a123] - 匹配a123中任意一个字符（a或1或2或3）
[\d\s] - 匹配任意一个数字或空白字符

b.

[1-9] - 匹配1-9中任意一个字符（字符编码递增）
[a-z]
[A-Z]
[a-zA-Z] - 匹配一个字母
[a-zA-Z\d_] 或 [a-zA-Z0-9_]- 匹配任意一个数字字母下划线
[ \t\n] - 匹配任意一个空白字符
[\u4e00-\u9fa5] - 匹配任意一个中文字符

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

[^abc]
[^2-8] - 匹配任意一个不是2到8的字符
[^\u4e00-\u9fa5] - 不知中文

检测符号

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

1）\b - 检查是否是单词边界

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

匹配一个字符串长度是6，每个字符串分别是abc123；并且要求abc和123之间是单词边界

re_str = r'abc\b123'
print(fullmatch(re_str, 'abc,123'))   # None

re_str = r'abc\b,123'
print(fullmatch(re_str, 'abc,123'))   # <re.Match object; span=(0, 7), match='abc,123'>

2) ^ - 在[]外使用，检查 ^ 所在位置是否是字符串开头

re_str = r'\d\d\d'

print(fullmatch(re_str, '345'))

print(search(re_str, 'sadjksfhsd123sdasda===898'))

print(findall(re_str, 'sadjksfhsd123sdasda===898'))

3) $- 检查$ 所咋在是否是字符串结尾

re_str = r'\d\d\d$'

print(fullmatch(re_str, '345'))

print(search(re_str, 'sadjksfhsd123sdasda===898'))

print(findall(re_str, 'sadjksfhsd123sdasda===898'))

控制次数的符号：

1. * - 匹配0次或多次

123a* - 123后a出现0次或多次

123， 123a, 123aa,.....

123\d* - 123后面出现0个或多个任意字符，如123，1230,123546

123[mnxy9]* - 123n,123m,123mmn,123999999,.....

re_str = r'abc0*123'
print(fullmatch(re_str, 'abc00000123'))

2. + - 匹配一次或多次

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

re_str = r'123[a-z]+'
print(fullmatch(re_str, '123sda'))

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

-?123 - 123, -123

re_str = r'_?abc'
print(fullmatch(re_str, 'abc'))

4. {}

1）{N} - 匹配N次

a{3} - 匹配三个a, aaa
\d{3} - 匹配三个任意数字， 123 ，546

2）{M,N} - 匹配M - N次（匹配至少M次最多N次）

3）{M,} - 至少匹配M次

4){,N} - 至多匹配N次

匹配电话号码

re_str = r'1[3-9]\d{9}'

匹配密码：6-12数字或字母

re_str = r'[a-zA-Z\d]{6,12}'

5.贪婪和非贪婪

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

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

非贪婪：在能够匹配成功的前提下，匹配次数尽可能少(在匹配次数后面加？)

*？
+?
??
{M,N}?
{,N}?
{M,}?

re_str = r'a.+'
print(search(re_str, 'hjsafkja==sa'))
# <re.Match object; span=(3, 12), match='afkja==sa'>
# 贪婪的取最多次

print(search(r'a\d{3,5}', 'fga123548ad'))
# <re.Match object; span=(2, 8), match='a12354'>

print(search(r'a\d{3,5}?', 'fga123548ad'))
# <re.Match object; span=(2, 6), match='a123'>

分支

1. | - 在两个中选择一个

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

re_str = r'abc|123'
print(fullmatch(re_str, 'abc'))
print(fullmatch(re_str, '123'))

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

re_str = r'\d\dabc|[A-Z]{2}abc'

分组

1.() - 将括号中的内容作为一个整体

1)整体操作

r'(\d\d|[A-Z]{2})abc'   # 匹配一个字符串：abc的前面是两个数字或者两个大写字母

r'([a-z]\d){3}'  - a8v8d9

2)分组 - 将结果分段

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

re_str = r'(\d{3})[a-z]{3}'
print(fullmatch(re_str, '344hsj'))
print(findall(re_str, 'add123358fw989ned131asd=jkD=as232dd1das313das--d5d'))
# ['989', '131', '313']

# 234hjk234,112kls112
re_str = r'(\d{3})[a-z]{3}\1'   # 重复第一个分组的内容

转义符号

1.加\

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

re_str = r'\d{3}\.[a-z]{3}'
print(fullmatch(re_str, '123.zxc'))

re_str = r'a\+\d{3}'
print(fullmatch(re_str, 'a+344'))

2.加[]

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

re_str = r'\d{3}[.][a-z]{3}'
print(fullmatch(re_str, '123.aaa'))

re模块

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

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

re_obj = compile(r'\d{3}')
fullmatch(r'\d{3}', '345')

re_obj.fullmatch('234')

字符串匹配

fullmatch(正则表达式, 字符串) - 让正则表达式和字符串完全匹配
match(正则表达式, 字符串) - 匹配字符串开头（字符串开头满足正则）

匹配成功返回匹配对象，匹配失败返回None

re_str = r'\d{3}'
print(fullmatch(re_str, '123'))
print(match(re_str, '123llj'))

1）匹配对象

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

a.获取匹配结果

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

print(result.group())
# 234=am
print(result.group(1))
# 234
print(result.group(2))
# am

获取匹配到的字符串在原字符串中的位置

result = match()

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

result = match(r'(\d{3})=([a-z]{2})', '234=am')
print(result.span())  # (0, 6)

print(result.span(2))  # (4, 6)
start, end = result.span(1)
print(start, end)
# 0 3

c.获取原字符串

匹配对象.string

print(result.string)
# 234=am

3.查找

1)search(正则表达式，字符串) - 在字符串中找到第一个满足正则表达式的子串，如果找到了

结果是匹配对象，找不到返回None

2)findall(正则表达式, 字符串) - 获取字符串中所有满足正则表达式的子串；返回值是一个列表

注意：如果正则表达式中有分组，列表中的匹配结果只会取分组匹配到的内容

3）finditer(正则表达式, 字符串) - 获取字符串中所有满足正则表达式的子串

result = search(r'\d{3}', 'dasqwe1321eqeq122asdaf')
print(result)

result = findall(r'\d{3}[a-z]{2}', 'sad123dwq541gda555dad5s5df5')
print(result)
# ['123dw', '541gd', '555da']

result = findall(r'(\d{3})[a-z]{2}', 'sad123dwq541gda555dad5s5df5')
print(result)
# ['123', '541', '555']

result = findall(r'(\d{3})([a-z]{2})', 'sad123dwq541gda555dad5s5df5')
print(result)
# [('123', 'dw'), ('541', 'gd'), ('555', 'da')]

result = finditer(r'(\d{3})([a-z]{2})', 'sad123dwq541gda555dad5s5df5')
group = []
group1 = []
group2 = []
for x in result:
    group.append(x.group())
    group1.append(x.group(1))
    group2 .append(x.group(2))

print(group)
print(group1)
print(group2)
# ['123dw', '541gd', '555da']
# ['123', '541', '555']
# ['dw', 'gd', 'da']

4.切割

split(正则表达式, 字符串) - 将字符串中满足正则表达式的子串作为切割点对字符串进行切割；返回一个字符串列表

result = split(r'\d+', 'das12dsa54gds875fsalos4548dds')
print(result)
# ['das', 'dsa', 'gds', 'fsalos', 'dds']

5.替换

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