1. 正则表达式的符号
- 正则表达式：用来做字符串查找、匹配、切割的一种工具
- python对正则表达式的支持：提供了re模块（python内置模块），包含字符串匹配、查找、切割等相关的方法
- fullmatch(正则表达式，字符串)：用正则表达式来和字符串进行匹配，看是否能够匹配成功
- 正则表达式：是一个符合正则规范的字符串
import re
if __name__ == '__main__':
# 注意：正则表达式的字符串，前面一般要加'r'来阻止转义。
# 因为正则表达式的符号中有很多带'\'的符号，其功能不是转义，而是表示特殊的意义
# 1. .：匹配一个任意字符
"""匹配两个任意字符的字符串"""
re_str = r'..'
"""匹配第一个字符是a第二个字符是b的字符串"""
re_str = r'ab'
"""匹配第一个是a，第二个字符是任意字符的字符串"""
re_str = r'a.'
print(re.fullmatch(re_str, 'ab'))
# 2. \w：匹配一个字符是字母、数字或者下划线
"""匹配第一个字符第二个字符都是字母、数字或下划线的字符串"""
re_str = r'\w\w'
print(re.fullmatch(re_str, 'b'))
re_str = r'\w.\w'
print(re.fullmatch(re_str, 'u@8'))
# 3. \s：匹配一个空白字符(空格，tab，换行)
"""匹配第一个字符是a第二个空白，第三个是b的字符串"""
re_str = r'a\sb'
print(re.fullmatch(re_str, 'a\nb'))
# 4. \d：匹配一个数字字符串
re_str = r'\d\d\d'
print(re.fullmatch(re_str, '123'))
"""匹配第一个是0，其他是数字的字符串"""
re_str = r'0\d\d'
print(re.fullmatch(re_str, '012'))
print(re.match(re_str, '0123'))
# 5. \b：检测边界(单词边界----一般的符号都可以作为单词边界)
"""匹配三个任意字符的前面和后面都是 单词边界 的字符串"""
re_str = r'\b...\b'
print(re.match(re_str, '432，121')) # 空格 , . ? 等这些字符都能作为边界
# 6. ^ ：匹配字符串开始(^The -- 匹配以The开头的字符串)
re_str = r'^The'
print(re.fullmatch(re_str, 'The'))
# 7. $：匹配字符串结束
re_str = r'abc$'
print(re.fullmatch(re_str, 'abc'))
print(re.findall(re_str, 'asdad da da abc'))
# 8. \W ：匹配非字母、数字、下划线
re_str = r'\W\w' # 第一个非字母数字下划线，第二个字母数字下划线
print(re.fullmatch(re_str, '%h'))
# 9. \S：匹配非空白字符
re_str = r'\S\d' # 第一个非空白，第二个数字
print(re.fullmatch(re_str, '#8'))
# 10. \D：匹配非数字字符
re_str = r'\D\w' # 第一个非数字，第二个字母数字下划线
print(re.fullmatch(re_str, '@j'))
# 11. \B：检测非边界
re_str = r'sad\Bb' # 匹配前三个是sad，第四个字符是b，并且检测d的后面、b的前面是非边界
print(re.fullmatch(re_str, 'sadb'))
print(re.match(re_str, 'sadb'))
运行结果：
<re.Match object; span=(0, 2), match='ab'>
None
<re.Match object; span=(0, 3), match='u@8'>
<re.Match object; span=(0, 3), match='a\nb'>
<re.Match object; span=(0, 3), match='123'>
<re.Match object; span=(0, 3), match='012'>
<re.Match object; span=(0, 3), match='012'>
<re.Match object; span=(0, 3), match='432'>
<re.Match object; span=(0, 3), match='The'>
<re.Match object; span=(0, 3), match='abc'>
['abc']
<re.Match object; span=(0, 2), match='%h'>
<re.Match object; span=(0, 2), match='#8'>
<re.Match object; span=(0, 2), match='@j'>
<re.Match object; span=(0, 4), match='sadb'>
<re.Match object; span=(0, 4), match='sadb'>
2. 正则表达式符号组合
import re
if __name__ == '__main__':
# 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, '6abc'))
"""
[0-9]：匹配0,1,2,3,4,5,6,7,8,9中的任意一个字符
[a-z]：匹配任意一个小写字母
[A-Z]：匹配任意一个大写字母
"""
print(re.fullmatch(r'[1-9]', '6'))
print(re.fullmatch(r'[a-zA-Z]', 'B'))
re_str = r'[]'
# 写一个正则表达式，判断一个字符串是数字字符串
re_str = r'\d\d*'
re_str = r'[0-9][0-9]*'
print(re.fullmatch(re_str, '0'))
# 写一个正则表达式，检测一个字符串是否是合格的标识符（字母数字下划线组成，数字不开头）
re_str = r'[a-zA-Z_]\w*'
print(re.fullmatch(re_str, 'sad98'))
# 2. [^]：匹配不在[]中出现的任意一个字符
"""匹配一个字符串，前三位是abc，第四位不是数字也不是字符a的字符串"""
re_str = r'abc[^\da]'
print(re.fullmatch(re_str, 'abc%'))
# 3. * ：匹配0次或者多次
"""匹配一个字符串，前面是0个或者多个数字字符，然后是abc"""
re_str = r'\d*abc'
print(re.fullmatch(re_str, '123abc'))
# 4. +：匹配一次或者多次
"""匹配一个字符串开头出现一次或者多个数字字符，然后再有0次或者多次数字、字母、下划线"""
re_str = r'\d+\w*'
print(re.fullmatch(re_str, '12u78abc'))
# 5. ?：匹配0次或者1次
re_str = r'[a-z]?123' # 前面出现0次或者一次小写字母，后面是123
print(re.fullmatch(re_str, 'z123'))
# 判断一个字符串是否是正整数字符串(除0)
re_str = r'[+]?[1-9]\d*'
print(re.fullmatch(re_str, '+0123'))
# 5. {N}：匹配N次
"""前面5个数字，然后是abc"""
re_str = r'\d{5}abc'
"""匹配[]里面任意出现3个，然后是abc"""
re_str = r'[12asd]{3}abc'
print(re.fullmatch(re_str, '1asabc'))
# 6. {N,}：匹配大于等于N次
"""前面至少三位数字，后面随便"""
re_str = r'\d{3,}.*'
print(re.fullmatch(re_str, '353453asdajkdk'))
# 7. {M,N}：匹配至少M次，最多N次
"""密码要求：数字字母组成，8-16位"""
re_str = r'[\da-zA-Z]{8,16}'
print(re.fullmatch(re_str, '123ui37f'))
# 8. | 分之（前后有一个满足就匹配成功）
"""匹配一个字符串，是三个数字字符或者是三个小写字符"""
re_str = r'\d{3}|[a-z]{3}'
print(re.fullmatch(re_str, 'ada'))
# 9. () 匹配的时候是分组，让括号中的正则条件变成一个整体
"""匹配一个字符串，abc整体重复三次"""
re_str = r'(abc){3}'
print(re.fullmatch(re_str, 'abcabcabc'))
re_str = r'(\d\w[0-3]){2}'
print(re.fullmatch(re_str, '2g16j3'))
运行结果：
<re.Match object; span=(0, 4), match='abca'>
<re.Match object; span=(0, 4), match='6abc'>
<re.Match object; span=(0, 1), match='6'>
<re.Match object; span=(0, 1), match='B'>
<re.Match object; span=(0, 1), match='0'>
<re.Match object; span=(0, 5), match='sad98'>
<re.Match object; span=(0, 4), match='abc%'>
<re.Match object; span=(0, 6), match='123abc'>
<re.Match object; span=(0, 8), match='12u78abc'>
<re.Match object; span=(0, 4), match='z123'>
None
<re.Match object; span=(0, 6), match='1asabc'>
<re.Match object; span=(0, 14), match='353453asdajkdk'>
<re.Match object; span=(0, 8), match='123ui37f'>
<re.Match object; span=(0, 3), match='ada'>
<re.Match object; span=(0, 9), match='abcabcabc'>
<re.Match object; span=(0, 6), match='2g16j3'>
3. 正则表达式
正则中：. \ [] {} () * + ? ^ $ | 这些字符有特殊意义，所以在正则表达式中，如果想要单纯的表达这些字符，需要在前面加 '\'
注意：1. - [] ^ \ 在括号中可能是特殊的符号，需要加\
2. . {} () * ? $ | + 在括号中可以不用加\，来表示字符
\N ---> 匹配前面第N个组中匹配到的内容
import re
if __name__ == '__main__':
re_str = r'\d+\.+\d'
print(re.fullmatch(re_str, '1.8'))
re_name = r'\w{6, 20}'
re_qq = r'[1-9]\d{4, 11}'
re_str = r'(([1-9]|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])\.){3}([1-9]|[1-9]\d|1\d{2}|2[0-4]\d|25[0-5])'
print(re.fullmatch(re_str, '10.7.181.111'))
运行结果：
<re.Match object; span=(0, 3), match='1.8'>
<re.Match object; span=(0, 12), match='10.7.181.111'>
4. re模块方法
"""__author__ = Percy"""
import re
if __name__ == '__main__':
# 1.compile(正则字符串) 将正则表达式字符串转换成正则表达式对象
# 转换成正则表达式对象后，可以通过对象调用相关方法
re_obct = re.compile(r'\w{6,12}')
print(re_obct.fullmatch('adadadd'))
print(re.fullmatch(r'\w{6,12}', 'adsadasda'))
# 2. fullmatch(正则表达式， 字符串) 从字符串开头匹配到结尾
# 返回值是匹配对象，如果匹配失败返回None
match = re.fullmatch('\w{3}', 'ada')
print(match)
# a.获取匹配到的结果
print(match.group())
# b.获取匹配到的范围
print(match.span())
# c.获取匹配到的开始下标和结束下标
print(match.start())
print(match.end())
# d.获取被匹配的字符串（原字符串）
print(match.string)
# 应用：判断一个字符串是否是某种字符串（判断账号、密码是否符合要求等）
# 3.match(正则表达式，字符串) 不完全匹配，从字符串开头开始匹配，匹配到正则表达式对应的范围为止
match = re.match(r'\w{3}', 'adahjknzdha')
print(match)
print(match.group())
print(match.string)
# 应用：判断一个字符串是否以某种字符串开头
# 4.search(正则表达式，字符串) 在指定的字符串中查找某种字符串（以正则表达式描述）,如果有多个满足条件的，只匹配第一个
# 返回值是匹配对象，如果找不到符合要求的返回None
print(re.search(r'\d{2,}[]a-z]', 'a3d4m-978jkad21'))
# 应用：判断一个字符串中是否包含某种字符串
# 5.findall(正则表达式，字符串) 去获取指定字符串中满足正则条件的所有的子串
# 返回值是列表，列表中是符合要求的字符串.没有满足要求的子串就返回[]
result = re.findall(r'[a-zA-Z](\d+)', 'a123bjkje456o')
print(result)
# 注意：在通过正则表达式获取子串的时候，可以通过正则表达式中添加括号，来约束获取的内容（只获取括号中匹配到的内容）
# 匹配的时候还是按原正则表达式去查找
# 应用：字符串提取
# 6.finditer(正则表达式，字符串) 用法和findall一样，只是返回值的类型不一样
# 返回一个迭代器，迭代器中的内容是匹配对象
# 注意：（）捕获部分无效
result = re.finditer(r'[a-zA-Z](\d+)', 'a123bjkje456o')
for match in result:
print(match)
# 7.split(正则表达式，字符串) 按正则表达式匹配到的字符串进行切割
# 返回值是列表，列表元素就是切割后被分段的字符串
result = re.split(r'\d+', 'd23jd7d623h23sd9jh')
print(result)
# 8.sub(正则表达式，新字符串，原字符串) 在原字符串中查找符合正则的子串，替换成新的字符串
"""将指定字符串中所有的'sb'替换成'*'"""
str1 = '你好sb,你是sb吗，不知道支援？这么垃圾还玩游戏'
result = re.sub(r'sb|垃圾', '**', str1)
print(str1, result)
运行结果：
<re.Match object; span=(0, 7), match='adadadd'>
<re.Match object; span=(0, 9), match='adsadasda'>
<re.Match object; span=(0, 3), match='ada'>
ada
(0, 3)
0
3
ada
<re.Match object; span=(0, 3), match='ada'>
ada
adahjknzdha
<re.Match object; span=(6, 10), match='978j'>
['123', '456']
<re.Match object; span=(0, 4), match='a123'>
<re.Match object; span=(8, 12), match='e456'>
['d', 'jd', 'd', 'h', 'sd', 'jh']
你好sb,你是sb吗，不知道支援？这么垃圾还玩游戏 你好**,你是**吗，不知道支援？这么**还玩游戏
练习：
一. 获取字符串中：
a.所有的正整数
b.所有的负整数
c.所有的浮点数
d.所有的非负浮点数
"""__author__ = Percy"""
"""
一.获取字符串中：
a.所有的正整数
b.所有的负整数
c.所有的浮点数
d.所有的非负浮点数
"""
import re
if __name__ == '__main__':
# 获取所有正整数
re_str = r'[^-0]\d*'
print(re.fullmatch(re_str, '0'))
print(re.fullmatch(re_str, '123'))
print(re.fullmatch(re_str, '-123'))
print(re.fullmatch(re_str, '0123'))
# 获取所有负整数
re_str = r'[-]\d*'
print(re.fullmatch(re_str, '-123'))
print(re.fullmatch(re_str, '123'))
# 获取所有的浮点数
re_str = r'[^0]\d*\.\d*|[^-]\d*\.\d*'
print(re.fullmatch(re_str, '1.23'))
print(re.fullmatch(re_str, '-1.23'))
# 获取所有非负浮点数
re_str = r'[^-]\d*\.\d*'
print(re.fullmatch(re_str, '1.23'))
print(re.fullmatch(re_str, '-1.23'))
运行结果：
None
<re.Match object; span=(0, 3), match='123'>
None
None
<re.Match object; span=(0, 4), match='-123'>
None
<re.Match object; span=(0, 4), match='1.23'>
<re.Match object; span=(0, 5), match='-1.23'>
<re.Match object; span=(0, 4), match='1.23'>
None
二、不定项选择题
- 能够完全匹配字符串“(010)-62661617”和字符串“01062661617”的正则表达式包括（ A,B,D ）
A. “(?\d{3})?-?\d{8}”
B. “[0-9()-]+”
C. “[0-9(-)]\d”
D. “[(]?\d[)-]\d”
2.能够完全匹配字符串“c:\rapidminer\lib\plugs”的正则表达式包括（ BC ）
A. “c:\rapidminer\lib\plugs”
B. “c:\rapidminer\lib\plugs”
C. “(?i)C:\RapidMiner\Lib\Plugs” ?i:将后面的内容的大写变成小写
D. “(?s)C:\RapidMiner\Lib\Plugs” ?s：单行匹配
3.能够完全匹配字符串“back”和“back-end”的正则表达式包括（ ABCD ）
短路操作：前面的为真了，就不会再执行后边的操作
A. “\w{4}-\w{3}|\w{4}” B. “\w{4}|\w{4}-\w{3}”
C. “\S+-\S+|\S+” D. “\w\b-\b\w|\w”
4.能够完全匹配字符串“go go”和“kitty kitty”，但不能完全匹配“go kitty”的正则表达式包括（A D）
:\1就是重复前面第一个()/组合里面的内容
：\2就是重复前面第二个()/组合里面的内容
A. “\b(\w+)\b\s+\1\b”
B. “\w{2,5}\s\1”
C. “(\S+) \s+\1”
D. “(\S{2,5})\s{1,}\1”
5.能够在字符串中匹配“aab”，而不能匹配“aaab”和“aaaab”的正则表达式包括（ BC ）
A. “a?b”
B. “a{,2}b”
C. “aa??b”
D. “aaa??b”
