一、正则表达式
注意：正则表达式的字符串，前面要加r阻止转义。
因为正则表达式的符号中有很多带''的符号，起功能不是转义，而是表示特殊的意义
1. '.' :匹配一个任意的字符
"""匹配两个任意字符的字符串"""
re_str = r'..'
print(re.fullmatch(re_str, 'ab'))
"""匹配两个指定字符的字符串"""
re_str = r'ab'
print(re.fullmatch(re_str, 'ab'))
"""匹配第一个字符是a，第二个是任意字符的字符串"""
re_str = r'a.'
print(re.fullmatch(re_str, 'ax'))
<_sre.SRE_Match object; span=(0, 2), match='ab'>
<_sre.SRE_Match object; span=(0, 2), match='ab'>
<_sre.SRE_Match object; span=(0, 2), match='ax'>
2. \w:匹配一个字符是字母、数字或者下划线
re_str = r'\w'
print(re.fullmatch(re_str, '_'))
re_str = r'\w.\w'
print(re.fullmatch(re_str, 'w!_'))
<_sre.SRE_Match object; span=(0, 1), match='_'>
<_sre.SRE_Match object; span=(0, 3), match='w!_'>
3. \s:匹配一个空白字符(空格、换行、制表符)
"""匹配第一个字符是a，第二个字符是空白，第三个字符是a的字符串"""
re_str = r'a\sa'
print(re.fullmatch(re_str, 'a\na'))
<_sre.SRE_Match object; span=(0, 3), match='a\na'>
4. \d:匹配一个数字字符
"""匹配第一个字符是0，后面2个都是数字的字符串"""
re_str = r'0\d\d'
print(re.fullmatch(re_str, '089'))
<_sre.SRE_Match object; span=(0, 3), match='089'>
5. \b:检测边界(单词边界---一般的符号都可以作为单词边界)
"""匹配三个任意字符的前面和后面都是单词边界的字符串"""
re_str = r'\b...\b'
print(re.match(re_str, 'sdf?ads'))
<_sre.SRE_Match object; span=(0, 3), match='sdf'>
6. ：检测字符串开始(The --- 匹配以The开头的字符串)
re_str = r'^The'
print(re.fullmatch(re_str, 'The'))
print(re.findall(r'^The', 'Thedasd sdfsdf '))
<_sre.SRE_Match object; span=(0, 3), match='The'>
['The']
7. $:检测字符串结束
re_str = r'abc$'
print(re.fullmatch(re_str, 'abc'))
print(re.findall(re_str, 'sfsdfabc'))
<_sre.SRE_Match object; span=(0, 3), match='abc'>
['abc']
8. \W:匹配非字母、数字、下划线
re_str = r'\W\w'
print(re.fullmatch(re_str, '@a'))
<_sre.SRE_Match object; span=(0, 2), match='@a'>
9. \S:匹配非空白字符
re_str = r'\S\S\d\d'
print(re.fullmatch(re_str, 'AE86'))
<_sre.SRE_Match object; span=(0, 4), match='AE86'>
10. \D:匹配非数字
"""匹配第一个数字是非数字字符，第二个字符是字母、数字、下划线"""
re_str = r'\D\w'
print(re.fullmatch(re_str, 'a_'))
<_sre.SRE_Match object; span=(0, 2), match='a_'>
11. \B:检测非边界
re_str = '\Babc'
print(re.findall(re_str, 'sabc'))
['abc']
二、正则表达式的符号组合
1. []:匹配中括号中出现的任意一个字符
"""匹配一个字符串，前三位是abc，第四位是'1'或者'a'"""
re_str = r'abc[1a]'
print(re.fullmatch(re_str, 'abca'))
"""第一位是数字或者下划线，后面是abc"""
re_str = r'[\d_]abc'
print(re.fullmatch(re_str, '_abc'))
<_sre.SRE_Match object; span=(0, 4), match='abca'>
<_sre.SRE_Match object; span=(0, 4), match='_abc'>
2.[^]:匹配不在[]中出现任意一个字符
"""匹配一个字符串，前三位是abc,第四位不是数字或's''d''f'"""
re_str = r'abc[^\dsdf]'
print(re.fullmatch(re_str, 'abc,'))
<_sre.SRE_Match object; span=(0, 4), match='abc,'>
3.* :匹配0次或者多次
"""匹配一个字符串，前面是0个或者多个数字字符"""
re_str = r'\d*abc'
print(re.fullmatch(re_str, '123abc'))
"""
[0-9]:匹配0,1,2,3,4,5,6,7,8,9中的一个
[a-z]:匹配任意一个小写字母
"""
re_str = r'[a-zA-Z]'
print(re.fullmatch(re_str, 'B'))
"""
写一个正则表达式，判断一个字符串是数字字符串(不能空串)
"""
re_str = r'\d\d*'
re_str = r'[0-9][0-9]*'
print(re.fullmatch(re_str, '456421'))
"""
写一个正则表达式能够匹配一个合格的标识符(字母数字下划线组成，数字不开头)
"""
re_str = r'[a-zA-z_]\w*'
print(re.fullmatch(re_str, '_sfd32'))
<_sre.SRE_Match object; span=(0, 6), match='123abc'>
<_sre.SRE_Match object; span=(0, 1), match='B'>
<_sre.SRE_Match object; span=(0, 6), match='456421'>
<_sre.SRE_Match object; span=(0, 6), match='_sfd32'>
4.+:匹配一次或者多次
"""匹配一个字符串开头出现一次或者多个数字字符，然后再有0个或者多个数字、字母、下划线"""
re_str = r'\d+\w*'
print(re.fullmatch(re_str, '1s3231sd'))
<_sre.SRE_Match object; span=(0, 8), match='1s3231sd'>
5.?:匹配0次或者1次
re_str = r'[a-z]?123'
print(re.fullmatch(re_str, 'x123'))
"""
写一个正则表达式能够匹配一个分数(0-100)
"""
"""
判断一个字符串是否是正整数字符串
'123' - T
'+123' - T
'0123' - F
'1203' - T
"""
re_str = r'[+]?[1-9]\d*'
print(re.fullmatch(re_str, '+224240'))
<_sre.SRE_Match object; span=(0, 4), match='x123'>
<_sre.SRE_Match object; span=(0, 7), match='+224240'>
6.{N}:匹配N次
"""字符串前面有5个数字，然后是abc"""
re_str = r'\d{5}abc'
re_str = r'[12ab]{3}abc'
print(re.fullmatch(re_str, '1baabc'))
<_sre.SRE_Match object; span=(0, 6), match='1baabc'>
7.{M,}:匹配大于等于M次
re_str = r'\d{3,}.*'
print(re.fullmatch(re_str, '1231sasd5f#@#'))
<_sre.SRE_Match object; span=(0, 13), match='1231sasd5f#@#'>
8.{M,N}:匹配至少M次，至多N次
"""密码要求：字母、数字组成，并且8-16位"""
re_str = r'[0-9a-zA-Z]{6,10}'
print(re.fullmatch(re_str, '321s35f'))
<_sre.SRE_Match object; span=(0, 7), match='321s35f'>
9. |:分之
"""匹配一个字符串，是三个数字字符或者三个字母字符"""
re_str = r'\d{3}|[a-z]{3}'
print(re.fullmatch(re_str, 'abc'))
<_sre.SRE_Match object; span=(0, 3), match='abc'>
10.()：匹配的时候分组，让括号中的正则条件变成一个整体
"""匹配一个字符串，abc整体重复3次"""
re_str = r'(abc){3}'
print(re.fullmatch(re_str, 'abcabcabc'))
<_sre.SRE_Match object; span=(0, 9), match='abcabcabc'>
"""------------以下内容了解-------------"""
11. *?:重复任意次，尽可能少得重复
re_str = r'ba*?b'
print(re.match(re_str, 'baabaa'))
<_sre.SRE_Match object; span=(0, 4), match='baab'>
12. +?:重复一次或多次，尽可能少重复
re_str = r'ba+?b'
print(re.match(re_str, 'baabaa'))
<_sre.SRE_Match object; span=(0, 4), match='baab'>
13. ??:重复0次或者1次，尽可能少重复
re_str = r'b??'
print(re.match(re_str, 'werwr'))
<_sre.SRE_Match object; span=(0, 0), match=''>
14. {N,}?重复至少N次，尽可能少重复
15. {M,N}?重复M到N次，尽可能少重复
三、正则表达式补充
特殊符号转义
- 正则中：
. \ [] {} () * + ? ^ $ | 这些符号有特殊意义，
所以在正则表达式中，如果想要单纯地表达这些字符，需要在前面加'\' - 注意：a.特殊的'-'在'[]'中是特殊符号
b. . {} () * + ? $ | 在'[]'中可以不加\来表示字符
c.[] ^ \ - 在'[]'中要加\来表示字符
re_str = r'\d+\.\d+'
print(re.match(re_str, '12.56'))
re_str = r'[\^]' # 匹配 字符 ^
re_str = r'[\\]' # 匹配 字符 \
re_str = r'[\[\]]'
"""
1.\n：匹配前面第n个括号中匹配到的内容
"""
re_str = r'([1-9][a-z]{2})asd\1'
print(re.match(re_str, '1dfasd1df'))
<_sre.SRE_Match object; span=(0, 5), match='12.56'>
<_sre.SRE_Match object; span=(0, 9), match='1dfasd1df'>
四、re模块方法
1.compile(正则字符串) 将正则表达式字符串转换成正则表达式对象
- 转换成正则表达式对象后，可以通过对象调用相关方法
re_object = re.compile(r'\w{6,12}')
print(re_object)
print(re_object.fullmatch('sjklfjf'))
print(re.fullmatch(r'\w{6,12}', 'sfdsff'))
re.compile('\\w{6,12}')
<_sre.SRE_Match object; span=(0, 7), match='sjklfjf'>
<_sre.SRE_Match object; span=(0, 6), match='sfdsff'>
2.fullmatch(正则表达式，字符串)：完全匹配，从字符串开头匹配到结尾
- 返回值是匹配对象,如果匹配失败就返回None
- 应用：判断一个字符串是否是某种字符串(判断账号、密码是否符合要求等)
match = re.fullmatch('\w{3}', 'gte')
print(match)
# a.获取匹配到的结果
print(match.group())
# b.获取到的匹配的范围
print(match.span())
# c.获取匹配到的开始下标和结束下标
print(match.start())
# d.获取到被匹配的字符串(源字符串)
print(match.string)
<_sre.SRE_Match object; span=(0, 3), match='gte'>
gte
(0, 3)
0
gte
3.match(正则表达式，字符串)不完全匹配，从字符开头开始匹配，匹配到正则表达式对应的范围为止
- 应用：判断一个字符串是否以某种字符串开头
match = re.match('\w{3}', 'gtx1190')
print(match)
print(match.group())
print(match.string)
<_sre.SRE_Match object; span=(0, 3), match='gtx'>
gtx
gtx1190
4.search(正则表达式，字符串):在指定的字符串中查找某种字符串(以正则表达式来描述),如果有多个满足条件的值，只匹配第一个，返回值是对象
- 返回值是匹配对象，如果找不到符合要求的字符串返回None
- 应用：判断一个字符串是否包含某种字符串
print(re.search(r'\d{2,}[a-z]', 'a233n333n'))
<_sre.SRE_Match object; span=(1, 5), match='233n'>
5.findall(正则表达式，字符串)去获取指定字符串中满足正则条件的所有的子字符串
- 返回值是列表，列表中是符合要求的字符串,没有满足要求的子字符串就返回空的列表
- 应用；提取满足条件的字符串
"""
获取满足[a-zA-Z](\d+)中的(\d+)部分
注意：在通过正则表达式获取子字符串的时候，可以通过在正则表达式中添加括号来约束获取的内容，只获取括号中的内容
查找的时候还是按原正则表达式去查找
"""
result = re.findall(r'[a-zA-Z](\d+)', '12a123b321dddeg465ef')
print(result)
['123', '321', '465']
6.finditer(正则表达式，字符串)用法和findall一样，只是返回值的类型不一样
- 返回一个迭代器,迭代器中的内容是匹配对象
- 注意：括号捕获部分无效
result = re.finditer(r'[a-zA-Z](\d+)', '12a123b321dddeg465ef')
print(result)
# print(result.__next__, next(result))
for match in result:
print(match)
<callable_iterator object at 0x0BB41550>
<_sre.SRE_Match object; span=(2, 6), match='a123'>
<_sre.SRE_Match object; span=(6, 10), match='b321'>
<_sre.SRE_Match object; span=(14, 18), match='g465'>
7.split(正则表达式，字符串)按正则表达式匹配到的字符串进行切割
- 返回值是列表，列表的元素就是切割后被分段的字符串
result = re.split(r'\d+', 's2f3d234fsd13f')
print(result)
result = re.split(r'[\*\-]', 's2f3*d2-34*fsd13f')
print(result)
['s', 'f', 'd', 'fsd', 'f']
['s2f3', 'd2', '34', 'fsd13f']
8.sub(正则表达式,新字符串,原字符串)在原字符串中查找符合正则表达式的子字符串，并且替换成新字符串
- 返回值是替换后的字符串
"""将指定字符串中的所有'sb'替换成'*'"""
str1 = '你好sb,你全家都是sb东方饭店'
result = re.sub(r'sb', '*', str1)
print(str1)
print(result)
你好sb,你全家都是sb东方饭店
你好*,你全家都是*东方饭店
