[Python知识库]python正则表达式

python正则表达式

1. 正则简介

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

python正则表达方式：r’正则表达式’
js的正则：/正则表达式/

re模块是Python提供的专门用来支撑正则表达式的一个模块
fullmatch函数:fullmatch(正则表达式，字符串) - 让正则表达式和指定字符串进行完全匹配，如果匹配失败则返回None

2. 匹配符号

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

# 匹配一个字符串有三个字符分别是a\b和c
re_str = r'abc'
print(fullmatch(re_str, 'abc'))

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

re_str = r'a.c'
print(fullmatch(re_str, 'abc'))
print(fullmatch(re_str, 'a-c'))

re_str = r'abc...'
print(fullmatch(re_str, 'abcm.p'))
print(fullmatch(re_str, 'abcfg/'))

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

re_str = r'a\db\dc'
print(fullmatch(re_str, 'a1b2c'))

2.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'))

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

2.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

2.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, 'amb'))

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, 'a5b'))
print(fullmatch(re_str, 'abb'))

2.8 [ ^字符集] - 匹配任意一个不在字符集任意一个字符
[ ^abc] - 匹配除了a、b、c以外的任意一个字符
[ ^a-z] - 匹配除了小写字母以外的任意一个字符
注意：[]中的^和-只有放在指定位置的时候才有特殊功能，否则就只是表示一个普通字符

3. 检测类符号

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

3.1 \b - 检测是否是单词边界

单词边界 - 能够区分出两个不同单词的符号都属于单词边界,列如：空白、标点符号、字符串开头、字符串结尾

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

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

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

# findall(正则表达式,字符串)  -  获取字符串中所有满足正则表达式的字串
str1 = '12dks,86as不会的56就开始34，19，5404 68 4 2'
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)

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

str1 = '12dks,86as不会的56就开始34，19，5404 68 4 2'
result3 = findall(r'\d\d\B', str1)
print(result3)

3.3 ^ - 检测是否是字符串开头

re_str = r'^\d\d'
str1 = '12dks,86as不会的56就开始34，19，5404 68 4 2'
print(fullmatch(re_str, '13'))
print(findall(r'^\d\d', str1))

3.4 $ - 检测是否以字符串结尾

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

4. 匹配次数

4.1 * - 匹配0次或多次（任意次数）
用法：匹配类符号*
a* - 匹配任意多个a
\d* - 匹配任意多个数字字符
[abc]* - 匹配任意多个[abc]

print(fullmatch(r'a*b', 'ab'))
print(fullmatch(r'a*b', 'aaab'))
print(fullmatch(r'\d*b', '45451b'))
print(fullmatch(r'[abc]*x', 'abcacbx'))

4.2 + - 匹配1次或多次（至少1次）

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

4.3 ? - 匹配0次或1次

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

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

print(fullmatch(r'\d{3}', '654'))
print(fullmatch(r'\d{3,5}', '654'))
print(fullmatch(r'\d{3,5}', '6554'))
print(fullmatch(r'\d{3,5}', '65544'))

print(fullmatch(r'\d{,5}', '8645'))
print(fullmatch(r'\d{,5}', '86457'))

print(fullmatch(r'\d{3,}', '8645'))
print(fullmatch(r'\d{3,}', '845'))

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

4.5 贪婪和非贪婪

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

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

print(match(r'a.*b', 'asgshb尽可能看电视'))  # sgshb

# asb , asbgsb , asbgsbthhb 有三种情况，因为贪婪，所有选择次数最多的一次,如果是非贪婪选择最少的次数
print(match(r'a.*b', 'asbgsbthhb尽可能看电视'))  # asbgsbthhb
print(match(r'a.*?b', 'asbgsbthhb尽可能看电视'))  # asb

5. 分组和分支

5.1 () - 分组

作用1：将（）中的内容作为一个整体，进行整体相关操作，例如，整体控制次数
作用2：通过’\M’重复前面第M个分组匹配到的结果，M从1开始

str1='18sa56er85vb'
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'ababababab'
print(fullmatch(r'(ab)+',str1))

str1=r'45asd45'
print(fullmatch(r'(\d{2})(asd)\1','19asd19'))

5.2 | - 分支

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

print(fullmatch(r'abc\d{2}|abc[A-Z]{3}','abcJJH'))
print(fullmatch(r'abc(\d{2}|[A-Z]{3})','abcJNH'))

5.3 转义符号

在特殊符号前加,让符号的功能消失，变成一个普通符号

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

如果是独立存在有特殊功能的符号，将符号放在[]中其功能也会自动消失

print(fullmatch(r'[+*?|()^$]abc','?abc'))
print(fullmatch(r'[\^abc\-z\]]123','^123'))

6. re模块

6.1 compile(正则表达式) - 编译正则表达式，返回一个正则表达式对象
fullmatch(正则表达式，字符串)
正则表达式对象.fullmatch(字符串)

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

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

result = re.fullmatch(r'(\d{3})([a-z]+)', '456a')
print(result)

6.2.1 获取匹配到的字符串

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

print(result.group())
print(result.group(1))
print(result.group(2))

6.2.2 获取匹配结果在原字符串中的位置信息

匹配对象.span() - 返回的是一个元组，元组中的元素是开始下标和结束下标，结束下标对应的位置取不到
匹配对象.span(N)

print(result.span())

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

result = re.search(r'\d{3}', 'HJd空间的123jsl,568')
print(result)
print(result.group())

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

result = re.findall(r'\d{2}', '34fgh908好几遍265,fghj56')
print(result)

result = re.findall(r'(\d{2})\D', '34fgh908好几遍265,fghj56')
print(result)

result = re.findall(r'(\d[a-z]){2}', '34f8gh9l0y8好几遍265k,fghj56')
print(result)

result = re.findall(r'(\d{2})-([a-z]{3})', '34-fyy8gh9l0y8好几遍265-ksf,fghj56')
print(result)

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

result = re.finditer(r'(\d{2})-([a-z]{3})', '34-fyy8gh94-vbl0y8好几遍265-ksf,fghj56')
print(result)
r1 = next(result)
print(r1, r1.group(), r1.group(1), r1.group(2))

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

result = re.split(r'\d+', 'saiuj2ds6sdv8sd53sa6dssd22wq')
print(result)

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

result = re.sub(r'\d', '*', 'UI上的卡8ac68爱好爱爱6荣誉533')
print(result)

message = 'fuck you ! tmIDS觉得阿里'
# result=re.sub(r'([fF]\s*[uU]\s*[cC]\s*[kK])|tm|sb','*',message)
result = re.sub(r'(?i)(f\s*u\s*c\s*k)|tm|sb', '*', message)
print(result)

6.8 flags参数

参数flags,用来设置正则参数

6.8.1 单行匹配和多行匹配参数：re.S、re.M(默认的)
单行匹配：可以匹配\n
多行匹配：不能和\n匹配
flags=re.S == r’(?s)正则表达式’
6.8.2 忽略大小写：re.I
flags=re.I == r’(?i)正则表达式’

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

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'))

练习

利用正则表达式完成下面的操作:

一、不定项选择题

1. 能够完全匹配字符串"(010)-62661617"和字符串"01062661617"的正则表达式包括（abd ）

A.r"\(?\d{3}\)?-?\d{8}"
B. r"[0-9()-]+"
C.r"[0-9(-)]*\d*"
D.r"[(]?\d*[)-]*\d*"

2. 能够完全匹配字符串“back”和“back-end”的正则表达式包括（ab c）
   A. r“\w{4}-\w{3}|\w{4}”
   B. r“\w{4}|\w{4}-\w{3}”
   C.r “\S±\S+|\S+”
   D. r“\w*\b-\b\w*|\w*”

3. 能够完全匹配字符串“go go”和“kitty kitty”，但不能完全匹配“go kitty”的正则表达式包括（ad）
   A.r “\b(\w+)\b\s+\1\b”
   B. r“\w{2,5}\s*\1”
   C. r“(\S+) \s+\1”
   D. r“(\S{2,5})\s{1,}\1”

4. 能够在字符串中匹配“aab”，而不能匹配“aaab”和“aaaab”的正则表达式包括（ bc）
   A. r“a*?b”
   B. r“a{,2}b”
   C. r“aa??b”
   D. r“aaa??b”

二、编程题

1.用户名匹配

? 要求: 1.用户名只能包含数字 字母 下划线

? 2.不能以数字开头

? 3.?度在 6 到 16 位范围内

re_str=r'[a-zA-Z_][a-zA-Z\d_]{5,15}'

2. 密码匹配

? 要求: 1.不能包含!@#￥%^&*这些特殊符号

? 2.必须以字母开头

? 3.?度在 6 到 12 位范围内

re_str=r'[a-zA-Z][^!@#￥%^&*]{5,11}'

3. ipv4 格式的 ip 地址匹配
   提示: IP地址的范围是 0.0.0.0 - 255.255.255.255

re_str=r'((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)\.){3}(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)'
print(fullmatch(re_str,'198.220.255.0'))

4. 提取用户输入数据中的数值 (数值包括正负数 还包括整数和小数在内) 并求和

例如:“-3.14good87nice19bye” =====> -3.14 + 87 + 19 = 102.86

result=findall(r'-?\d+\.?\d*','-3.14good87nice19bye')
print(result)
sum1=0
for x in result:
    sum1+=float(x)
print(sum1)

5. 验证输入内容只能是汉字

   re_str=r'[\u4e00-\u9fa5]+'
   

6. 匹配整数或者小数（包括正数和负数）

   re_str=r'[-+]?([1-9]\d*|0)(\.\d+)?'
   

7. 验证输入用户名和QQ号是否有效并给出对应的提示信息

   要求：
   用户名必须由字母、数字或下划线构成且长度在6~20个字符之间
   QQ号是5~12的数字且首位不能为0

   print(fullmatch(r'[a-zA-Z\d_]{6,20}','sa51as_ghs'))
   print(fullmatch(r'[1-9]\d{4,11}','123456789'))
   
   输出：
   <re.Match object; span=(0, 10), match='sa51as_ghs'>
   <re.Match object; span=(0, 9), match='123456789'>
   

8. 拆分长字符串：将一首诗的中的每一句话分别取出来

   ? poem = ‘窗前明月光，疑是地上霜。举头望明月，低头思故乡。’

poem = '窗前明月光，疑是地上霜。举头望明月，低头思故乡。'
result=findall(r'[\u4e00-\u9fa5]+',poem)
print(result)

输出：
['窗前明月光', '疑是地上霜', '举头望明月', '低头思故乡']