python3正则表达式与re模块

re模块

re模块是python提供的专门用来支持正则表达式的一个模块

fullmatch函数：fullmatch(正则表达式,字符串) — 让正则表达式与指定字符串进行完全匹配,匹配失败返回None

正则语法

正则表达式 — 正则表达式是让一个字符串复杂问题变得简单的工具

写正则表达式的主要工作：用正则符号描述清楚相关字符串的规则

python正则表示方式：r’正则表达式’

re模块相关函数

1. compile(正则表达式) — 编译正则表达式，返回一个正则表达式对象

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

re_obj = re.compile(r'(\d{3})-([A-Z])')
result = re_obj.fullmatch('999-Z')
print(result)

• 1
• 2
• 3

2. fullmatch(正则表达式,字符串) — 让正则表达式和整个字符串进行匹配(完全匹配),匹配失败返回None，成功

   返回匹配对象

   match(正则表达式,字符串) — 匹配字符串开头(判断字符串开头是否满足正则表达式)，匹配失败返回None，

   成功返回匹配对象

   匹配对象：

   a)、获取匹配到的字符串

   ​ 1.匹配对象.group() / 匹配对象.group(0) — 获取整个正则匹配到的结果

   ​ 2.匹配对象.group(N) — 获取第N个分组匹配到的结果

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

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

   例：（3,6）表示3,4,5

   ​ 匹配对象.span(N)

   print(result.group())   #999-Z
   print(result.group(1))   #999
   print(result.group(2))   #Z
   
   print(result.span())
   print(result.span(1))
   

   • 1
   • 2
   • 3
   • 4
   • 5
   • 6

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

   result = re.search(r'(\d{2})\D','15大萨达156阿萨德68无法6546是非得失28sdsa')
   print(result)
   print(result.group())
   

   • 1
   • 2
   • 3

4. findall(正则表达式,字符串) — 获取字符串中所有满足正则的子串，返回的是列表，列表中的元素是子串(无分组时)

   如果正则中只有一个分组:返回的列表中的元组是每个分组匹配到的结果

   如果正则中有两个或两个以上的分组：返回的列表中的元素是元组，元组中的元素是每个分组匹配到的结果

result = re.findall(r'\d{2}','15大萨达156阿萨德68无法6546是非得失28sdsa')
print(result)
# 截取  一个分组
result1 = re.findall(r'(\d{2})\D','15大萨达156阿萨德68无法6546是非得失28sdsa')
print(result1)

• 1
• 2
• 3
• 4
• 5

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

   果(多分组时)

result1 = re.finditer(r'(\d{2})-([a-z]{3})','99-zzx理解科技馆11-jlk黄金鸡块')
r1 = next(result1)
print(r1,r1.group(),r1.group(1),r1.group(2))

• 1
• 2
• 3

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

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

   ​ 割

result2 = re.split(r'\d+','沙发上5非常撒啊67高的6sfsa8撒放')
print(result2)  #['沙发上', '非常撒啊', '高的', 'sfsa', '撒放']

result2 = re.split(r'\d+','沙发上5非常撒啊67高的6sfsa8撒放',3)
print(result2)  #['沙发上', '非常撒啊', '高的', 'sfsa8撒放']

• 1
• 2
• 3
• 4
• 5

7. sub(正则表达式,字符串1,字符串2) — 将字符串2中所有满足正则表达式的子串替换为字符串1

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

result2 = re.sub(r'(?i)\d|sb','*','沙发上5非常SB撒啊67高的6sfsa8撒放')   #(?i)  ---  忽略大小写
print(result2)  #沙发上*非常*撒啊**高的*sfsa*撒放

• 1
• 2

8. flags参数

   上述(1-7)没一个函数都有一个参数flags,用来设置正则参数

   1)、单行匹配和多行匹配参数:re.S、re.M(默认)

   单行匹配:”.”可匹配\ n

   多行匹配:”.”不能匹配\ n

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

   2)、忽略大小写:re.I

   flags = re.I <==> r’(?i)正则表达式’

   3)、多参数

   flags = re.S|re.I <==> (?is) / (?si)

# re.S & re.M
print(re.fullmatch(r'z.x','z\nx',flags=re.M))   #None
print(re.fullmatch(r'z.x','z\nx',flags=re.S))   #<re.Match object; span=(0, 3), match='z\nx'>
print(re.fullmatch(r'(?s)z.x','z\nx'))   #<re.Match object; span=(0, 3), match='z\nx'>

# re.I
print(re.fullmatch(r'zzx','ZZx',flags=re.I))   # <re.Match object; span=(0, 3), match='ZZx'>
print(re.fullmatch(r'(?i)zzx','ZZx'))   # <re.Match object; span=(0, 3), match='ZZx'>

# 多参数
print(re.fullmatch(r'(?is)zz.x','ZZ\nx',flags=re.I))   # <re.Match object; span=(0, 4), match='ZZ\nx'>
print(re.fullmatch(r'(?is)zz.x','ZZ\nx',flags=re.I|re.S))   # <re.Match object; span=(0, 4), match='ZZ\nx'>

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12

匹配符号

1. 普通字符(普通符号)

   在正则中除了有特殊功能或特殊意义之外的符号

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

2. . — 匹配任意一个字符

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

re_str = r'z.x'
print(fullmatch(re_str, 'zzx'))   #<re.Match object; span=(0, 3), match='zzx'>
print(fullmatch(re_str, 'zxx'))   #<re.Match object; span=(0, 3), match='zxx'>

• 1
• 2
• 3

3. 正则中’ \ ‘系列

   \d — 匹配任意一个数字字符
   \s — 匹配任意一个空白字符(空白字符：空格、回车(\ n)、制表符(\ t))
   \D — 匹配任意一个非数字字符
   \S — 匹配任意一个非空白字符

# '\'  ---  \d
re_str1 = r'z\dz\dx\d'
print(fullmatch(re_str1,'z9z9x9'))  #<re.Match object; span=(0, 6), match='z9z9x9'>

# '\'  ---  \s
re_str2 = r'z\sz\sx'
print(fullmatch(re_str2,'z z x'))
print(fullmatch(re_str2,'z\nz\tx'))
print(fullmatch(re_str2,'z  z   x'))   #None

# '\'  ---  \D \S
re_str3 = r'z\Sz\Dx'
print(fullmatch(re_str3,'z+z+x'))
print(fullmatch(re_str3,'z+z9x'))

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14

4. [字符集] — 匹配字符集中任意一个字符

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

   [多个普通字符] — 例：[zzx] –> 可以匹配z或z或x

   [包含\开头的特殊符号的字符集] — 例：[\dzzx] –> 可以匹配任意数字或z或z或x

   [包含减号在两个字符之间的字符集] — 减号表示前到后的区间（注意：减号前面的字符编码必须小于后面的）

   例：
   [a-z] — 匹配任意一个小写字母

   [a-d] — 匹配a,b,c,d中一个小写字母

   [1-9] — 匹配1-9中任意一个数字

   [\ u4e00-\ u9fa5] — 匹配任意一个中文字符

   [a-zA-Z] — 匹配任意一个字母

   [a-z\d] — 匹配任意一个小写字母或者任意一个数字

   re_str4 = r'9[zzx]9'
   print(fullmatch(re_str4,'9z9'))
   print(fullmatch(re_str4,'9x9'))
   
   # \开头的字符集
   re_str5 = r'z[\dzzx]'
   print(fullmatch(re_str5,'z9'))
   

   • 1
   • 2
   • 3
   • 4
   • 5
   • 6
   • 7

5. [^字符集] — 匹配任意一个非字符集中的字符

   例：[ ^zzx] — 匹配除z、z、x之外的任意一个字符
   [ ^a-z] — 匹配除小写字母以外的任意一个字符
   注意：[]中的-和^只有放在指定位置时候才有特殊功能，否则在[]中就是一个普通符号

re_str6 = r'zzx[^\u4e00-\u9fa5]'
print(fullmatch(re_str6,'zzx雄'))   #None 匹配非中文字符
re_str6 = r'zzx[^a-zA-Z]'
print(fullmatch(re_str6,'zzx9'))

• 1
• 2
• 3
• 4

检测类符号

检测类符号的存在不影响被匹配的字符串长度，它的作用是在匹配成功的前提下检测符号所在的位置是否符合要求

检测类符号的用法：先去掉检测类符号，看是否能匹配成功；

若失败，整个正则匹配失败；匹配成功再来看检测类符号所在的位置是否符合要求

findall(正则表达式,字符串) — 获取字符串中所有满足正则表达式的子串(以列表形式返回)

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

string = '45阿萨德 84 释放掉 998 符号发过火ddf25 sdf61'
result = findall(r'\d\d',string)
print(result)  #['45', '84', '99', '25', '61']

• 1
• 2
• 3
• 4
• 5
• 6

1. \ b — 检测是否是单词边界

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

   尾

string = '45阿萨德 84 释放掉 998 符号发过火ddf25 sdf61'

• 1

result1 = findall(r'\b\d\d\b',string)
print(result1)  #['84']

• 1
• 2

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

result2 = findall(r'\d\d\B',string)
print(result2)  #['45', '99']

• 1
• 2

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

result3 = findall(r'^\d\d',string)
print(result3)  #['45']

• 1
• 2

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

result4 = findall(r'\d\d$',string)
print(result4)   #['61']

• 1
• 2

匹配次数

1. *— 匹配0次或多次(任意次)

   用法：匹配类符号*

   z* — 匹配任意多个z

   \d* — 匹配任意多个数字字符

   [zzx]* — 匹配任意多个z、z、x

# *
re_str = r'z*x'
print(fullmatch(re_str,'zzx'))

# \d
re_str1 = r'\d*zzx'
print(fullmatch(re_str1,'999zzx'))

# []*
re_str2 = r'[zzx]*999'
print(fullmatch(re_str2,'zzxzzx999'))

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11

2. ±– 匹配1次或多次(至少一次)

   用法：匹配类符号+

3. ？ — 匹配0次或1次

   用法：匹配类符号？

re_str3 = r'[+-]?\d\d'
print(fullmatch(re_str3,'-99'))
print(fullmatch(re_str3,'+99'))
print(fullmatch(re_str3,'99'))

• 1
• 2
• 3
• 4

4. {}
   {N} — 匹配N次

   {M,N} — 匹配M到N次

   {,N} — 匹配最多N次

   {M,} — 匹配至少M次

   注意：匹配次数对应的符号前面必须是匹配类符号 例：fullmatch(r’+{2,3},’++’) 报错

   # {N}
   re_str4 = r'\d{3}'   #匹配三次数字
   print(fullmatch(re_str4,'999'))
   # {M,N}
   re_str4 = r'\d{1,3}'   #匹配1-3次数字
   print(fullmatch(re_str4,'999'))
   # {,N}
   re_str4 = r'\d{,3}'      #匹配最多3次数字
   print(fullmatch(re_str4,''))
   # {M,}
   re_str4 = r'\d{1,}'   #匹配至少1次数字
   print(fullmatch(re_str4,'9999999'))
   

   • 1
   • 2
   • 3
   • 4
   • 5
   • 6
   • 7
   • 8
   • 9
   • 10
   • 11
   • 12

5. 贪婪与非贪婪

   在匹配次数不确定时，匹配模式分为贪婪和非贪婪两种，默认是贪婪模式

   在匹配成功的前提下，贪婪是匹配次数选最多的那个次数，非贪婪是匹配次数最少的次数

   *、+、？、{M，N}、{M，}、{，N} — 贪婪
   *?、+?、？?、{M，N}?、{M，}?、{，N}? — 非贪婪

print(match(r'z.*x','zzxccvbxmnbx'))
# <re.Match object; span=(0, 12), match='zzxccvbxmnbx'>  因为默认贪婪所以取匹配成功最长的结果

print(match(r'z.*?x','zzxccvbxmnbx'))
# <re.Match object; span=(0, 3), match='zzx'>  非贪婪，取匹配成功最短的结果

• 1
• 2
• 3
• 4
• 5

分组与分支

分组

1. () — 分组

   作用1：将()中的内容作为一个整体，进行整体相关操作 例：整体控制次数

   作用2：通过’\M’重复前面第M个分组匹配到的结果，M从1开始

   作用3：捕获(findall讲)

   str1 = '78nm34ms10xp'
   print(fullmatch(r'(\d\d[a-z]{2}){3}',str1))
   
   str2 = 'zxzxzxzx'
   print(fullmatch(r'(zx)+',str2))
   
   str3 = '999zzx999'
   print(fullmatch(r'(\d{3})([a-z]{3})\1',str3))  #匹配开头三个数字与结尾三个数字相同的中间为三个小写字母的字符串
   

   • 1
   • 2
   • 3
   • 4
   • 5
   • 6
   • 7
   • 8

2. | — 分支

   正则1|正则2 — 先用正则1进行匹配，若成功则匹配成功；若不成功再用正则2进行匹配

# 同时匹配'abc98'和'abcMNP'
print(fullmatch(r'abc(\d{2}|[A-Z]{3})','abc99'))
print(fullmatch(r'abc(\d{2}|[A-Z]{3})','abcJKL'))

• 1
• 2
• 3

3. 转义符号

   在特殊符号前加反斜杠，使符号的功能消失，变成一个普通符号

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

print(fullmatch(r'\d\+\d{2}','9+99'))
print(fullmatch(r'\[\d{3}\]','[999]'))

• 1
• 2

练习

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

一、不定项选择题

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

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

2. 能够完全匹配字符串“back”和“back-end”的正则表达式包括（ A BCD）
   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” （\s前有一个空格！）
   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”

二、编程题

from re import fullmatch,findall,split

• 1

1.用户名匹配

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

​ 2.不能以数字开头

​ 3.⻓度在 6 到 16 位范围内

user_name = input('请输入用户名:')
re_str = r'[a-zA-Z_][a-zA-Z_0-9]{5,15}'
re_str = fullmatch(re_str,user_name)
if (re_str != None):
    print(f'用户名{user_name}合法')
else:
    print(f'用户名{user_name}不合法')

• 1
• 2
• 3
• 4
• 5
• 6
• 7

2. 密码匹配

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

​ 2.必须以字母开头

​ 3.⻓度在 6 到 12 位范围内

password = input('请输入密码:')
re_str1 = r'(?i)^[a-z][^!@#¥%^&*]{5,11}'
re_str1 = fullmatch(re_str1,password)
if (re_str1 != None):
    print(f'密码{password}合法')
else:
    print(f'密码{password}不合法')

• 1
• 2
• 3
• 4
• 5
• 6
• 7

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

'''
0~9：\d
10~99:[1-9]\d
100~199:1\d{2}
200~249:2[0-4]\d
250~255:25[0-5]

0~9|10~99 <==>[1-9]?\d
'''
ip_address = input('输入一个IP地址:')
re_str2 = r'((25[0-5]|2[0-4]\d|((1\d{2})|([1-9]?\d)))\.){3}(25[0-5]|2[0-4]\d|((1\d{2})|([1-9]?\d)))'
print(fullmatch(re_str2,ip_address))
if (re_str2 != None):
    print(f'地址{ip_address}合法')
else:
    print(f'地址{ip_address}不合法')

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16

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

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

• 1

string1 = input('输入一个字符串:')
re_str3 = r'[+-]?\d+[.]?\d*'
list_str = findall(re_str3,string1)
# print(list_str)
# 列表推导式
# list_str = [eval(item) for item in list_str]
# print(sum(list_str))
# reduce
print(reduce(lambda x,y:x + float(y),list_str,0))

• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9

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

   string2 = input('输入字符串:')
   re_str4 = r'[\u4e00-\u9fa5]+'
   re_str4 = fullmatch(re_str4,string2)
   if (re_str4 != None):
       print(f'字符串{string2}合法')
   else:
       print(f'字符串{string2}非法')
   

   • 1
   • 2
   • 3
   • 4
   • 5
   • 6
   • 7

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

   string3 = input('输入字符串:')  #asd15ad+12ad0.2ad-12dsd-1.03
   # 整数：[+-]?([1-9]\d*|0)
   #小数：[+-]?([1-9]\d*|0)\.\d+
   re_str5 = r'[+-]?([1-9]\d*|0)(\.\d+)?'
   print(findall(re_str5,string3))  #['15', '+12', '0.2', '-12', '-1.03']
   

   • 1
   • 2
   • 3
   • 4
   • 5

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

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

   user_name = input('输入用户名:')
   qq_number = input('输入QQ账号:')
   re_str6 = r'(?i)[0-9a-z_]{6,20}'
   re_str7 = r'[1-9]\d{4,11}'
   name_outcome = fullmatch(re_str6,user_name)
   number_outcome = fullmatch(re_str7,qq_number)
   if(name_outcome == None):
       length = len(user_name)
       if(length < 6):
           print('用户名过短！')
       elif(length > 20):
           print('用户名过长！')
       else:
           print('用户名存在字母、数字或下划线以外的字符！')
   if(number_outcome == None):
       length = len(qq_number)
       if(length < 5):
           print('QQ号必须是5位以上的数字！')
       elif(length > 12):
           print('QQ号必须是12位以下的数字！')
       elif(int(qq_number[0]) == 0):
           print('QQ号首位必须是非0的数字！')
       else:
           print('QQ号存在字母、数字或下划线以外的字符！')
   if(number_outcome and name_outcome):
       print('输入合法！')
   

   • 1
   • 2
   • 3
   • 4
   • 5
   • 6
   • 7
   • 8
   • 9
   • 10
   • 11
   • 12
   • 13
   • 14
   • 15
   • 16
   • 17
   • 18
   • 19
   • 20
   • 21
   • 22
   • 23
   • 24
   • 25
   • 26

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

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

poem = '窗前明月光，疑是地上霜。举头望明月，低头思故乡。'
re_str8 = r'[，。]'
print(split(re_str8,poem)[:-1])  #无论哪首诗的末尾都是句号，不打印

• 1
• 2
• 3