day16-正则表达式

day16-正则表达式

正则表达式匹配符号

re模块是python内置的专门提供处理正则表达式函数的模块

from re import fullmatch

正则表达式是一种可以让字符串处理变得很简单的工具

正则表达式就是通过各种正则符合来描述字符串的规则

在不同的编程语言中，正则的语法是相同的，但是表示方式不同：python - ‘正则表达式’，js - /正则表达式/

正则符合

普通字符 - 普通字符在正则表达式中表示这个符号本身

fullmatch(正则表达式，字符串) - 判断字符串是否符号正则所描述的规则，如果符号结果不是None，否则是None

re_str = 'abc'    # 规则：一个字符串有三个字符，分别是a、b和c
result = fullmatch(re_str, 'abc')
print(result)

. - 匹配一个任意字符

‘a.b’ - 匹配一个长度是3的字符串，第一个字符是a，最后字符是b, 中间一个是任意字符

re_str = 'a.b'
result = fullmatch(re_str, 'akb')
print(result)    # <re.Match object; span=(0, 3), match='akb'>

result = fullmatch(re_str, 'a+b')
print(result)    # <re.Match object; span=(0, 3), match='a+b'>

result = fullmatch(re_str, 'x+b')
print(result)    # None

result = fullmatch(re_str, 'a++b')
print(result)    # None

re_str = 'xy..'     # 匹配一个长度是4，前两个字符是x和y,后面是两个任意字符的字符串
result = fullmatch(re_str, 'xyj就')
print(result)    # <re.Match object; span=(0, 4), match='xyj就'>

\d - 匹配一个任意数字

re_str = 'a\db'    # 匹配一个长度是3，第一个字符是a，最后一个字符是b，中间是一个任意数字字符
result = fullmatch(re_str, 'a9b')
print(result)    # <re.Match object; span=(0, 3), match='a9b'>

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

result = fullmatch(re_str, 'axb')
print(result)    # None

re_str = 'a\d\d\d'
result = fullmatch(re_str, 'a238')
print(result)   # <re.Match object; span=(0, 4), match='a238'>

\s - 匹配一个空白字符

空白字符：空格字符，\n, \t

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

result = fullmatch(re_str, 'abc\t123')
print(result)    # result = fullmatch(re_str, 'abc 123')

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

result = fullmatch(re_str, 'abc123')
print(result)   # None

\w - 匹配一个字母，数字或者下划线（ASCII码标意外的字符都可以匹配）

re_str = '\d\w\d'
result = fullmatch(re_str, '2看8')
print(result)

\D - 匹配任意一个非数字字符

\d - 匹配任意一个非空白字符

re_str = 'a\Db'
result = fullmatch(re_str, 'a9b')
print(result)     # None

result = fullmatch(re_str, 'a就b')
print(result)    # <re.Match object; span=(0, 3), match='a就b'>

re_str = '\d\S\d'
result = fullmatch(re_str, '2=8')
print(result)    # <re.Match object; span=(0, 3), match='2=8'>

result = fullmatch(re_str, '2 8')
print(result)    # None

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

注意：a.一个[]只能匹配一个字符
     b.在[]中可以将-放在两个字符之间表示范围，但是-前面的字符的编码值必须小于后面的字符的编码值
     c. 在[]中-只有在两个字符之间才有特殊意义，如果在最前面或者最后面就表示-本身

[a1+]  - 匹配字符a或者字符1或者字符+
[\dxy] 、 [x\dy] 、 [xy\d] - 匹配一个任意数字或者x或者y

[1-9]  - 匹配1到9的任意一个数字字符
[a-z]  - 匹配任意一个小写字母
[A-Z]  - 匹配任意一个大写字母
[a-zA-Z]
[\u4e00-\u9fa5]   -  匹配任意一个中文字符

下列写法都支持：

[a-z+=/] [1a-z2] [2-8a-z] [\da-z]

re_str = 'a[xy0]b'    # 匹配一个长度是3，第一个字符是a，最后一个是b，中间是x、y、0 中的任意一个字符的字符串
result = fullmatch(re_str, 'a0b')
print(result)

re_str = 'a[\dmn]b'
result = fullmatch(re_str, 'amb')
print(result)

re_str = 'a[1-9]b'
result = fullmatch(re_str, 'a9b')
print(result)

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

[^abc] - 匹配除了a,b,c以外的任意字符

[^\d] - 匹配任意一个非数字字符

[^a-z] - 匹配任意一个非小写字母的字符

re_str = '\d[^abc]\d'
print(fullmatch(re_str, '3好6'))

re_str = '\d[abc^]\d'
print(fullmatch(re_str, '3^6'))

正则语法

正则表达式是一种工具；一种专门用做字符串匹配的工具，能够在某些情况下让字符串的处理变得非常简单

正则式用来描述字符串规则

fullmatch（正则表达式，字符串）- 判断正则表达式是否和字符串完全匹配，如果不匹配返回None

检测符号

匹配符号要求一个符号必须对应一个字符，会影响字符串长度的描述；

检测符号，不会匹配字符，也不会影响字符串长度，它是在匹配成功的前提下对指定位置的字符进行检测

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

单词边界 - 所有能够区分出两个不同单词的符号，例如：空白字符、标点符号、字符串开头和字符串结尾

re_str = r'abc\b\s123'
print(fullmatch(re_str, 'abc 123'))

2）\B - 检测是否不是单词边界

re_str = r'abc\B123'
print(fullmatch(re_str, 'abc123'))

3）^ - 检测是否式字符串开头

re_str = r'abc^123'
print(fullmatch(re_str, 'abc123'))    # None

re_str = r'^abc123'
print(fullmatch(re_str, 'abc123'))

re_str = r'^\d\d'
print(fullmatch(re_str, '89'))
print(search(re_str, '98asdgfag38上课的飞机和45'))

4）$ - 检测是否式字符串结尾

re_str = r'\d\d$'
print(search(re_str, '海兽祭祀34sdjh728kjsj28'))

匹配次数

1） * - 0次或多次

a* - 字符a出现0次或者多次

\d* - 任意数字出现0次或多次（实质是\d在正则中出现0次或多次）

[字符集]* - 字符集中任意字符出现0次或者多次（每次都可以是任意一个）

re_str = r'a*bc'
print(fullmatch(re_str, 'bc'))
print(fullmatch(re_str, 'abc'))
print(fullmatch(re_str, 'aaabc'))

re_str = r'a\d*c'
print(fullmatch(re_str, 'ac'))
print(fullmatch(re_str, 'a1c'))
print(fullmatch(re_str, 'a12c'))

re_str = r'a[A-Z]*c'
print(fullmatch(re_str, 'ac'))
print(fullmatch(re_str, 'aKc'))
print(fullmatch(re_str, 'aKOKc'))

2）+ - 1次或多次（至少一次）

re_str = r'a[A-Z]+c'
print(fullmatch(re_str, 'ac'))    # None
print(fullmatch(re_str, 'aKc'))
print(fullmatch(re_str, 'aKOKc'))

3）？ - 0次或1次

re_str = r'[+]?[1-9]\d*'
print(fullmatch(re_str, '+8300'))

4）{}

{N} - 匹配N次
{M,N} - 匹配M到N次
{M,} - 匹配至少M次
{,N} - 匹配最多N次

re_str = r'\d{3}'
print(fullmatch(re_str, '298'))

# 用户名的要求：全部由数字或者字母组成，长度是3~6位
re_str = r'[\da-zA-Z]{3,6}'
print(fullmatch(re_str, '2k9'))

print(fullmatch(r'a{3,}123', 'aaaa123'))
print(fullmatch(r'a{,3}123', 'aa123'))

5）贪婪和非贪婪

在匹配次数不确定的时候匹配模式有两种：贪婪(默认)和非贪婪(在不确定次数后面加?)

贪婪：在能匹配成功的前提下，匹配次数选最多的(+、、?、{M,N}、{M,}、{,N})
非贪婪：在能匹配成功的前提下，匹配次数选最少的(+?、?、??、{M,N}?、{M,}?、{,N}?)

贪婪模式：

re_str = r'a.+b'
print(search(re_str, 'xxamnbpppb上到b===='))   # <re.Match object; span=(2, 13), match='amnbpppb上到b'>
# amnb  /  amnbpppb  /  amnbpppb上到b

非贪婪模式：

re_str = r'a.+?b'
print(search(re_str, 'xxamnbpppb上到b===='))   # <re.Match object; span=(2, 6), match='amnb'>

html = "<div><p class='title'>王者荣耀</p><img src=''><p class='score'>9.5</p></div>"
re_str = r"<p class='title'>.+?</p>"
print(search(re_str, html)

分组

（）

用法一：整体操作
a{2,3}
(ab){2,3}

用法二：重复
\M - 重复前面第M个分组中匹配到的内容

用法三：捕获
re中的findall在获取子串的时候，如果正则中有分组，只会获取分组匹配到的结果

print(fullmatch(r'ab{2,3}', 'abbb'))
print(fullmatch(r'(ab){2,3}', 'ababab'))

# 两个数字两个字母的结构重复3到5次,类似:89nm78jk89mk
print(fullmatch(r'(\d{2}[a-z]{2}){3,5}', '89jh34ko90pp'))

re_str = r'(\d)\1abc\1'
print(fullmatch(re_str, '88abc8'))

re_str = r'M(\d[a-z])N\1([A-Z])\2'
print(fullmatch(re_str, 'M4aN4aKK'))

re_str = r'a\d{2}b'
print(findall(re_str, 'mmma78bkkka72bll-a90b=56=='))   # ['a78b', 'a72b', 'a90b']

re_str = r'a(\d{2})b'
print(findall(re_str, 'mmma78bkkka72bll-a90b=56=='))   # ['78', '72', '90']

分支

|

正则1|正则2|正则3|…
先用正则1进行匹配，如果匹配成功整个正则就匹配成功；如果失败就用正则2进行匹配，如果成功整个正则就匹配成功，
如果失败就用正则3进行匹配，以此类推…

# 示例：写一个正则能够匹配一个字符串: abc后面是三个数字或者abc是三个大写字母
re_str = r'abc\d{3}|abc[A-Z]{3}'
print(fullmatch(re_str, 'abc234'))

re_str = r'abc(\d{3}|[A-Z]{3})'
print(fullmatch(re_str, 'abcKNM'))

转义字符

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

re_str = r'\d{2}\.\d{2}'
print(fullmatch(re_str, '23.45'))

re_str = r'\d\+'
print(fullmatch(re_str, '8+'))

re_str = r'\\dabc'
print(fullmatch(re_str, r'\dabc'))

re_str = r'\(\d{2}\)'
print(fullmatch(re_str, '(89)'))

注意：在这种中独立存在有特殊意义的符号，放到[]中，它的意义会自动消失

re_str = r'[.+*]abc'
print(fullmatch(re_str, '+abc'))

re_str = r'[ab\]cA\-D]123'
print(fullmatch(re_str, '-123'))

re模块的使用

compile（正则表达式）- 编译正则表达式，返回正则对象

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

正则表达式对象.fullmatch(字符串)

print(re_obj.fullmatch('789'))

re.fullmatch(正则表达式，字符串)

print(re.fullmatch(r'\d{3}', '789'))

匹配

fullmatch(正则, 字符串) - 让整个字符串和正则进行匹配，匹配失败返回None,匹配成功返回匹配对象
match(正则, 字符串) - 让字符串的开头和正则进行匹配，匹配失败返回None,匹配成功返回匹配对象

print(re.match(r'\d{3}', '345京东方卡号就assdf=='))

匹配对象

result = re.match(r'(\d{2})([a-z]{3})([A-Z]{2})', '34knmHK收到货发')
print(result)

匹配到的字串

# 匹配对象.group() /  匹配对象.group(0)   -   获取整个正则匹配到的子串
# 匹配对象.group(N)   -  获取第N个分组匹配到的子串
print(result.group())    # '34knmHK'
print(result.group(1))   # 34
print(result.group(3))   # HK

匹配范围 - 匹配到的字串在原字符串中的下标范围

匹配对象.span()

print(result.span())   # [0, 7)
print(result.span(2))  # [2, 5)

查找

search(正则, 字符串) - 在字符串查找第一个满足正则的子串，如果找到了返回匹配对象，找不到返回None
findall(正则, 字符串) - 获取字符串中所有满足正则的子串，返回值是列表，列表中的元素是字符串或者元组
finditer(正则, 字符串) - 获取字符串中所有满足正则的子串, 返回值是迭代器，迭代器中的元素是匹配对象

search

print(re.search(r'\d{3}', 'hsjs453舒克舒克3442jsk==='))

findall

# 没有分组：['453', '344']
print(re.findall(r'\d{3}', 'hsjs453舒克舒克3442jsk==='))

# 有一个分组： ['092', '786', '119']
print(re.findall(r'a(\d{3})', 'abm678十几年a092sdjb8239==-a786lksa119Kjd'))

# 有两个或者两个以上的分组: [('bm', '678'), ('jb', '823'), ('sa', '119')]
print(re.findall(r'([a-z]{2})(\d{3})', 'abm678十几年a092sdjb8239==-a786lksa119Kjd'))

print(re.findall(r'(\d|[a-z])[A-Z]{2}', 'hKM-水电费8MN速度快的9PP'))

finditer

result = re.finditer(r'([a-z]{2})(\d{3})', 'abm678十几年a092sdjb8239==-a786lksa119Kjd')
print(result)
print(list(result))

切割和替换

split（正则，字符串）- 将字符串中满足这种的字串作为切割点

sub（正则，字符串1，字符串2）- 将字符串2中满足这种的字串全部替换成字符串1

result = re.split(r'\d+', 'asjj823kasjkdfh299jSDK飞机和478sdjfh3上课的家伙5上看到回复')
print(result)

result = re.sub(r'\d+', '+', 'asjj823kasjkdfh299jSDK飞机和478sdjfh3上课的家伙5上看到回复')
print(result)