2021-08-02

正则表达式

1.正则表达式

1
2
3

re 模块是python提供的专门用来支持正则表达式的模块
fullmatch函数:
fullmatch(正则表达式,字符串) - 让正则表达式和指定

2.正则语法

正则表达式 - 正则表达式是一个让字符串复杂问题的变得简单的工具
写正则表达式的主要工作，用正则符号描述清楚相关字符串的规则

python正则比表示方式：r'正则表达式'
js的正则：/正则表达式/

1) 普通字符（普通符号）
在正则除了有特殊功能或者特殊意义以外的符号；
普通字符在正则中表示这个符号本身。

# 匹配一个字符串有三个字符分别是a、b和c

from re import fullmatch

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

2) .  -  匹配任意一个字符
注意：一个.只能匹配一个任意字符

# 匹配一个字符，长度是三，第一个字符是a，最后一个字符是c，a和c之间是任意一个字符
re_str = r'a.c'
print(fullmatch(re_str, 'abc'))
print(fullmatch(re_str, 'a+c'))
print(fullmatch(re_str, 'a好c'))

re_str = r'abc...'
print(fullmatch(re_str, 'abcm./'))
print(fullmatch(re_str, 'abcm\t/'))
print(fullmatch(re_str, 'abc G/'))

3) \d  - 匹配任意一个数字字符
re_str = r'a\d\dc'
print(fullmatch(re_str, 'a78c'))
print(fullmatch(re_str, 'a00c'))

4) \s   -   匹配任意一个空白字符
空白字符：空格、回车(\n)、制表符(\t)

re_str = r'a\sb'
print(fullmatch(re_str, 'a b'))
print(fullmatch(re_str, 'a\nb'))
print(fullmatch(re_str, 'a\tb'))
print(fullmatch(re_str, 'a  b'))    # None

1	* 5) \w - 匹配任意一个字母、数字或者下划线（不好用）

6）
\D   -   匹配任意一个非数字字符
\S   -   匹配任意一个非空白字符

print(fullmatch(r'a\Sb\D', 'a>b='))
print(fullmatch(r'a\Sb\D', 'a b='))         # None
print(fullmatch(r'a\Sb\D', 'a>b0'))         # None

7) [字符集]    -   匹配字符集中任意一个字符
注意：一个[]只能匹配一个字符
[多个普通字符]      -    例如：[abc]，可以匹配a或者b或者c
[包含\开头的特殊符号的字符集]    -   例如：[\dabc]，可以匹配任意数据或者a或者b或者c

[包含减号在两个字符之间的字符集]   -   这个时候的减号表示谁到谁(注意：减号前面的字符的编码必须小于减号后面的)
例如：
[a-z]     -   匹配任意一个小写字母
[a-d]     -   匹配a、b、c、d中的任意一个字符
[A-Z]     -   匹配任意一个大写字母
[1-9]     -   匹配1到9中任意一个数字字符
[\u4e00-\u9fa5]     -   匹配任意一个中文字符
[a-zA-Z]、[A-Za-z]   -   匹配任意一个字母
[a-z123]    -   匹配任意一个小写字母，或者1或者2或者3
[a-z\d]     -   匹配任意一个小写字母或者任意一个数字


re_str = r'a[xym]b'
print(fullmatch(re_str, 'axb'))
print(fullmatch(re_str, 'ayb'))
print(fullmatch(re_str, 'amb'))
print(fullmatch(re_str, 'azb'))     # None

re_str = r'a[16]b'
print(fullmatch(re_str, 'a1b'))
print(fullmatch(re_str, 'a6b'))

re_str = r'a[a\db]b'
print(fullmatch(re_str, 'a1b'))
print(fullmatch(re_str, 'aab'))
print(fullmatch(re_str, 'abb'))

print(fullmatch(r'x[a-z]y', 'xmy'))

print(fullmatch(r'x[a-zA-Z]y', 'xmy'))
print(fullmatch(r'x[a-zA-Z]y', 'xKy'))

print(fullmatch(r'x[a-zA-Z*&]y', 'x*y'))
print(fullmatch(r'x[a-zA-Z*&]y', 'xMy'))

print(fullmatch(r'x[0-9]y', 'x5y'))

print(fullmatch(r'x[-09]y', 'x-y'))
print(fullmatch(r'x[-09]y', 'x0y'))
print(fullmatch(r'x[-09]y', 'x9y'))

8) [^字符集]   -   匹配任意一个不在字符集任意一个字符
[^abc]   -   匹配除了a、b、c以外的任意一个字符
[^a-z]   -   匹配除了小写字母以外的任意一个字符

print(fullmatch(r'a[^\u4e00-\u9fa5]c', 'a是c'))      # None
print(fullmatch(r'a[^a-zA-Z]c', 'aKc'))             # None
print(fullmatch(r'a[a-z^]c', 'a^c'))

注意：[]中的-和^只有放在指定位置的时候才有特殊功能，否则在[]中就是一个普通的符号。

3.检测类符号

from re import fullmatch, findall

检测类符号的存在不影响被匹配的字符串长度，它的作用是在匹配成功的前提下检测符号所在的位置是否符号要求。
检测类符号的用法：先去掉检测类符号，看是否能匹配成功，如果失败整个正则匹配失败。如果成功再来看检测类符号所在的位置是否符合要求。

1. \b  - 检测是否是单词边界
单词边界    -   能够区分出两个不同单词的符号都属于单词边界,例如：空白、标点符号、字符串开头、字符串结尾

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

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

print(fullmatch(r'abc\s\b123', 'abc 123'))


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


str1 = '12ksksj78ss 34抗生素,89 试7试看90 56 江苏省23'
result1 = findall(r'\d\d', str1)
print(result1)

result2 = findall(r'\d\d\b', str1)
print(result2)

result3 = findall(r'\b\d\d\b', str1)
print(result3)

2. \B   -   检测是否是非单词边界

result3 = findall(r'\d\d\B', str1)
print(result3)

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

re_str = r'^\d\d'
print(fullmatch(re_str, '12'))
print(findall(r'^\d\d',  str1))

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

re_str = r'\d\d$'
print(fullmatch(re_str, '67'))

4.匹配次数

from re import fullmatch, match, findall
import requests

1. *    -   匹配0次或者多次(任意次数)
用法：匹配类符号*
a*      -      匹配任意多个a
\d*     -      匹配任意多个数字字符   

print(fullmatch(r'a*b', 'b'))
print(fullmatch(r'a*b', 'aab'))
print(fullmatch(r'a*b', 'aaaaaaab'))
print(fullmatch(r'\d*b', '245899b'))
print(fullmatch(r'[abc]*x', 'aabccax'))

2. +    -   匹配1次或多次(至少一次)

print(fullmatch(r'a+b', 'b'))     # None
print(fullmatch(r'a+b', 'ab'))
print(fullmatch(r'a+b', 'aaaaab'))

3. ?    -   匹配0次或1次

re_str = r'[-+]?[1-9]\d'
print(fullmatch(re_str, '-12'))
print(fullmatch(r'a?b', 'b'))
print(fullmatch(r'a?b', 'ab'))
print(fullmatch(r'a?b', 'aab'))     # None

4. {}
{N}     -      匹配N次
{M,N}   -      匹配M到N次
{,N}    -      匹配最多N次
{M,}    -      匹配至少M次
* == {0,}
+ == {1,}
? == {0,1}

print(fullmatch(r'\d{4}', '5670'))

print(fullmatch(r'\d{3,5}', '234'))
print(fullmatch(r'\d{3,5}', '2334'))
print(fullmatch(r'\d{3,5}', '23342'))
print(fullmatch(r'\d{3,5}', '233429'))          # None
print(fullmatch(r'\d{3,5}', '23'))              # None

print(fullmatch(r'\d{,5}', '23'))
print(fullmatch(r'\d{,5}', ''))
print(fullmatch(r'\d{,5}', '899080'))           # None

print(fullmatch(r'\d{3,}', '23'))           # None
print(fullmatch(r'\d{3,}', '23234234233'))

# 注意：匹配次数对应的符号的前面必须是匹配类符号
'''print(fullmatch(r'+{2,3}', '++'))     # re.error '''

5. 贪婪和非贪婪
在匹配次数不确定的时候，匹配模式分为贪婪和非贪婪两种，默认是贪婪模式。
在匹配成功的前提下，贪婪是匹配次数选最多的那个次数；非贪婪是匹配次数最少的那个次数。

*、+、?、{M,N}、{M,}、{,N}     -     贪婪的
*?、+?、??、{M,N}?、{M,}?、{,N}?     -     非贪婪的

print(match(r'\d{3}', '234hj监管机构'))
print(match(r'a.*b', 'asmmdb监管机构'))     # asmmdb
print(match(r'a.*?b', 'asmmdb监管机构'))    # asmmdb

# 'asb'、'asbmmb'、'asbmmbdb' 有三种情况可以成功，因为贪婪所以最后匹配次数最多的情况
print(match(r'a.*b', 'asbmmbdb监管机构'))       # asbmmbdb
print(match(r'a.*?b', 'asbmmbdb监管机构'))      # asb

# 实例
response = requests.get('http://api.tianapi.com/auto/index?key=c9d408fefd8ed4081a9079d0d6165d43&num=10')
result = findall(r'"title":"(.+?)"', response.text)
print(result)

5.分组和分支

from re import fullmatch
1. ()   -   分组
作用1：将()中的内容作为一个整体，进行整体相关操作，例如，整体控制次数
作用2：通过 '\M' 重复前面第M个分组匹配到的结果， M从1开始
作用3：捕获(在findall中讲)

str1 = '78nm34ms10xp'
print(fullmatch(r'\d\d[a-z]{2}\d\d[a-z]{2}\d\d[a-z]{2}', str1))
print(fullmatch(r'(\d\d[a-z]{2}){3}', str1))

str1 = r'abababab'
print(fullmatch(r'(ab)+', str1))


print(fullmatch(r'(\d{2})abc\1', '89abc89'))
print(fullmatch(r'(\d{2})abc\1', '89abc34'))        # None

'''print(fullmatch(r'\d{2}abc\1', '89abc89'))     # re.error'''  

print(fullmatch(r'(\d{3})([a-z]{3})-\2', '234ams-ams'))
print(fullmatch(r'(\d{3})([a-z]{3})-\1', '234ams-234'))
print(fullmatch(r'(\d{3})([a-z]{3})-\2\1', '234ams-ams234'))
print(fullmatch(r'(\d{3})([a-z]{3})-\1{2}', '234ams-234234'))

''' print(fullmatch(r'(\d{3})-\2([a-z]{3})', '234ams-ams'))     #  re.error '''

2. |    -   分支
正则1|正则2     -   先用正则1进行匹配，如果成就直接匹配成功，如果匹配失败再用正则2进行匹配

# 要求能同时匹配'abc98' 和 'abcMKP'
print(fullmatch(r'abc\d{2}|abc[A-Z]{3}', 'abcKMP'))
print(fullmatch(r'abc(\d{2}|[A-Z]{3})', 'abcMKP'))

3. 转义符号
在特殊符号前加\，让符号的功能消失，变成一个普通符号

print(fullmatch(r'\+\d{3}', '+234'))
print(fullmatch(r'\[\d{3}\]', '[234]'))
print(fullmatch(r'\\dabc', '\dabc'))

# 如果是独立存在有特殊功能的符号，将符号放入[]中其功能也会自动消失
print(fullmatch(r'[+*?|()^$.]abc', '$abc'))
print(fullmatch(r'[\^abc\-z\]]123', ']123'))

6.模块

import re
compile(正则表达式)   -  编译正则表达式，返回一个正则表达式对象

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

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

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

2. 
fullmatch(正则表达式, 字符串)   -  让正则表达式和整个字符串进行匹配(完全匹配)，匹配失败返回None，匹配成功返回匹配对象
match(正则表达式, 字符串)   -   匹配字符串开头（判断字符串的开头是否符合正则的规则），匹配失败返回None，匹配成功返回匹配对象

result = re.fullmatch(r'(\d{3})-([A-Z]+)', '345-K')
print(result)    # <re.Match object; span=(0, 3), match='345'>  - 匹配对象

1) 获取匹配到的字符串
匹配对象.group() /  匹配对象.group(0)  - 获取整个正则匹配到的结果
匹配对象.group(N)  -  获取第N个分组匹配到的结果 

print(result.group())       # 345-K
print(result.group(1))      # 345
print(result.group(2))      # K

3. search(正则表达式, 字符串)   -   获取字符串中第一个满足正则表达式的子串。返回结果是None或者匹配对象

result = re.search(r'\d{3}', '试试看234ksjs,345')
print(result)       # <re.Match object; span=(3, 6), match='234'>
print(result.group())       # 234


2) 获取匹配结果在原字符串中的位置信息
匹配对象.span()  - 返回的是一个元组，元组中的元素是开始下标和结束下标，结束下标对应的位置取不到
匹配对象.span(N)

print(result.span())

4.
findall(正则表达式, 字符串)  - 获取字符串中所有满足正则的子串，返回的是列表，列表中的元素是子串(没有分组的时候)
如果正则中只有一个分组：返回的列表中的元素是每个分组匹配到的结果
如果正则中有两个或两个以上的分组: 返回的列表中的元素是元组，元组中的元素是每个分组匹配到的结果

result = re.findall(r'\d{2}', '34ssd908计算机上23，udh89,试试89123')
print(result)   # ['34', '90', '23', '89', '89', '12']

result = re.findall(r'(\d{2})\D', '34ssd908计算机上23，udh89,试试89123')
print(result)   # ['34', '08', '23', '89']

result = re.findall(r'((\d[a-z]){2})', '2m4m司机师傅9k0o试试3k5l--')
print(result)       # [('2m4m', '4m'), ('9k0o', '0o'), ('3k5l', '5l')]

result = re.findall(r'(\d{2})-([a-z]{3})', '23-msn数据是98-kop圣诞节发货')
print(result)       # [('23', 'msn'), ('98', 'kop')]

5.finditer(正则表达式, 字符串)  -   获取字符串中所有满足正则的子串，返回的是一个迭代器，迭代器是匹配对象

result = re.finditer(r'(\d{2})-([a-z]{3})', '23-msn数据是98-kop圣诞节发货')
print(result)
r1 = next(result)
print(r1, r1.group(), r1.group(1), r1.group(2))

6. split(正则表达式, 字符串)    -   将字符串中所有满足正则表达式的子串作为切割点，对字符串进行切割
re.split(正则表达式, 字符串, N)     -   将字符串中前N个满足正则表达式的子串作为切割点，对字符串进行切割

result = re.split(r'\d+', '是是9564s双生视界09世纪东方和3d失敬失敬2试试')
print(result)

7. 
sub(正则表达式, 字符串1, 字符串2)  - 将字符串2中所有满足正则表达式的子串替换成字符串1
sub(正则表达式, 字符串1, 字符串2, N)  - 将字符串2中前N个满足正则表达式的子串替换成字符串1

result = re.sub(r'\d+', '*', '是是9564s双生视界09世纪东方和3d失敬失敬2试试')
print(result)

8. flags参数
上面的每一个函数都一个参数flags，用来设置正则参数
1) 单行匹配和多行匹配参数：re.S、re.M(默认的)
单行匹配：.可以匹配\n
多行匹配：.不能和\n匹配

flags=re.S <==>  r'(?s)正则表达式'

2) 忽略大小写：re.I
flags=re.I  <==>  r'(?i)正则表达式'

flags=re.S|re.I  <==>  r'(?si)正则表达式'

print(re.fullmatch(r'a.b', 'a\nb', flags=re.M))     # None
print(re.fullmatch(r'a.b', 'a\nb'))                 # None
print(re.fullmatch(r'a.b', 'a\nb', flags=re.S))
print(re.fullmatch(r'(?s)a.b', 'a\nb'))

print('---------------------------------------------------')
print(re.fullmatch(r'abc', 'abc'))
print(re.fullmatch(r'abc', 'Abc'))      # None
print(re.fullmatch(r'abc', 'ABc', flags=re.I))
print(re.fullmatch(r'(?i)abc', 'ABc'))

print(re.fullmatch(r'a.b', 'A\nb', flags=re.S|re.I))
print(re.fullmatch(r'(?is)a.b', 'A\nb'))

徐明勇的技术专栏

1689904829@qq.com

正则表达式

1.正则表达式

2.正则语法

注意：[]中的-和^只有放在指定位置的时候才有特殊功能，否则在[]中就是一个普通的符号。

3.检测类符号

4.匹配次数

5.分组和分支

6.模块