1.正则表达式的符号
正则表达式：用来做字符串查找，匹配，切割用的一种工具
python对正则表达式的支持：提供了re模块（python内置模块）,包含字符串匹配，查找，切割等方法
fullmatch(正则表达式，需要匹配的字符串)： 用正则表达式和字符串进行匹配，看是否能够匹配成功
正则表达式：是一个符合正则表达式规范的字符串
import re
if __name__ == '__main__':
# 注意：正则表达式的前面要加r来阻止转义，因为正则表达式的符号中带有很多'/'的符号，不是转义，而是表示特殊的意义
# 1. .: 匹配一个任意字符
"""匹配两个任意字符的字符串"""
re_str = '..'
"""匹配第一个字符是a第二个字符是b的字符串"""
re_str = 'ab'
"""匹配第一个字符是a，第二个字符是任意字符的字符串"""
re_str = 'a.'
print(re.fullmatch(re_str,'ab'))
# 2. \w :匹配一个字符是字母、数字或者下划线
"""匹配第一个字符是数字、字母、下划线，第二个字符是数字、字母、下划线的字符串"""
re_str = r'\w\w'
print(re.fullmatch(re_str,'ab'))
re_str = r'\w.\w'
print(re.fullmatch(re_str,'u(0'))
# 3. \s ：匹配一个空白字符（空格，换行，制表符）
"""匹配第一个字符是a,第二个字符是空白，第三个字符是b的字符串"""
re_str = 'a\sb'
print(re.fullmatch(re_str,'a\tb'))
# 4. \d :匹配一个数字字符
re_str = '\d\d\d'
print(re.fullmatch(re_str,'120'))
# 匹配第一个字符是0，后面两个字符是数字字符的字符串
re_str = r'0\d\d'
print(re.fullmatch(re_str,'007'))
# 5. \b :检测边界(单词边界----一般的符号都可以作为单词边界)
#检测三个字符的前面和后面都是单词边界的字符串
re_str = r'\b...\b'
print(re.match(re_str,'019'))
# 6. ^ :匹配字符串的开始(^The -- 匹配以The开头的字符串)
re_str = '^The'
print(re.match(re_str,'The'))
# 7. $ :检测字符串结束
re_str = r'abc$'
print(re.match(re_str,'is abc'))
# 8. \W : 匹配非数字，字母，下划线
re_str = '\W\w'
print(re.match(re_str,'&k '))
# 9. \S 匹配非空白字符
re_str = r'\S\d'
print(re.match(re_str,'p8'))
# 10. \D 匹配非数字
"""匹配第一个字符是非数字字符，第二个 字符是字母，数字，下划线"""
re_str = r'\D\w'
# 11. B: 检测非边界
re_str = r'\Badb'
print(re.fullmatch(re_str,'abc'))
print(re.match(re_str,'abc0'))
<_sre.SRE_Match object; span=(0, 2), match='ab'>
<_sre.SRE_Match object; span=(0, 2), match='ab'>
<_sre.SRE_Match object; span=(0, 3), match='u(0'>
<_sre.SRE_Match object; span=(0, 3), match='a\tb'>
<_sre.SRE_Match object; span=(0, 3), match='120'>
<_sre.SRE_Match object; span=(0, 3), match='007'>
<_sre.SRE_Match object; span=(0, 3), match='019'>
<_sre.SRE_Match object; span=(0, 3), match='The'>
None
<_sre.SRE_Match object; span=(0, 2), match='&k'>
<_sre.SRE_Match object; span=(0, 2), match='p8'>
None
None
2.正则表达式组合
mport re
if __name__ == '__main__':
# 1. [] 匹配[]中出现的任意一个字符
"""匹配一个字符串，前三位是abc，第四位是字符a或1"""
re_str = r'abc[1a]'
print(re.fullmatch(re_str,'abca'))
"""第一位是数字或者是下划线，后面是abc"""
re_str = r'[\d_]abc'
print(re.fullmatch(re_str,'9abc'))
# 2. [^]匹配不在[]中出现的任意一个字符
"""匹配一个字符串，前三个是abc，第四位不是数字也不是字符a"""
re_str = r'abc[^\da]'
print(re.fullmatch(re_str,'abcl'))
# 3. * 匹配0次或者多次
"""匹配一个字符串，前面是0个或者多个数字字符，后面是abc"""
re_str = r'\d*abc'
print(re.fullmatch(re_str,'123abc'))
"""
[0-9] :匹配0,1,2，3,4，5，6,7,8,9中的任一字符
[1-8] :匹配1，2,3,4,5,6,7,8,
[a-z] :匹配任意一个小写字母
[A-Z] :匹配任意一个大写字母
[a-zA-Z]: 匹配所有的字母
"""
print(re.fullmatch(r'[1-6]','6'))
print(re.fullmatch(r'[a-zA-Z]', 'w'))
# 写一个正则表达式，判断一个字符串是数字表达式[不能是字符串]
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,'_we'))
# 4. + :匹配一次或者多次
"""匹配一个字符串开头出现一次或者多次数字字符，然后再有0次或者多次数字，字母，下划线"""
re_str = r'\d+\w*'
print(re.fullmatch(re_str,'16u78abc'))
# 5. ? :匹配0次或者1次
re_str = r'[a-z]?123'
print(re.fullmatch(re_str,'w123'))
# 判断一个字符串是一个正整数字符串 '123' ->成功 '+123'--成功 '0123'--None
re_str = r'\+?[1-9]\d*'
re_str = r'[+]?[1-9]\d*'
print(re.fullmatch(re_str,'+12'))
# 5. {N} 匹配N次
"""前面5个数字，然后abc"""
re_str = r'\d{5}abc'
print(re.fullmatch(re_str,'12345abc'))
re_str = r'[12ab]{3}abc'
print(re.fullmatch(re_str,'1ababc'))
# 6. {N,} 匹配大于等于N次
"""字符串至少三位数字"""
re_str = r'\d{3,}.*'
print(re.fullmatch(re_str,'123dshaouiddfgiohsdoi fdhio'))
# 7. {M,N} 匹配至少M到N次
"""密码要求：数字，字母组成，密码8-16位"""
re_str = r'[0-9a-zA-Z]{8,16}'
print(re.fullmatch(re_str,'hdsa23782jxld'))
# 8. | :分支
"""匹配一个字符串，三个数字字符或者三个小写字母"""
re_str = r'\d{3}|[a-z]{3}'
print(re.fullmatch(re_str,'123'))
# 9. () :匹配的时候分组，让括号中的正则条件变成一个整体
"""匹配一个字符串，abc整体重复3次"""
re_str = r'(abc){3}'
print(re.fullmatch(re_str,'abcabcabc'))
re_str = r'(\d\w[0-3]){2}'
print(re.fullmatch(re_str,'9w3220'))
"""=======以下的了解======="""
# 尽可能少，就是在能匹配的情况下，取最小的一次
# 10 *？ ：重复任意次，尽可能少
re_str = r'a*?'
print(re.match(re_str,'aaaa'))
# 11 +? 重复一次或者多次
re_str = r'ba+?'
print(re.match(re_str,'baaa'))
# 12 ?? 重复0次或者1次，尽可能少重复
re_str = r'b??'
# 13 {N,}? 重复至少N次，尽可能少的重复
# 14 {M,N}？ 重复M到N次 ，尽可能少的重复
<_sre.SRE_Match object; span=(0, 4), match='abca'>
<_sre.SRE_Match object; span=(0, 4), match='9abc'>
<_sre.SRE_Match object; span=(0, 4), match='abcl'>
<_sre.SRE_Match object; span=(0, 6), match='123abc'>
<_sre.SRE_Match object; span=(0, 1), match='6'>
<_sre.SRE_Match object; span=(0, 1), match='w'>
<_sre.SRE_Match object; span=(0, 1), match='0'>
<_sre.SRE_Match object; span=(0, 3), match='_we'>
<_sre.SRE_Match object; span=(0, 8), match='16u78abc'>
<_sre.SRE_Match object; span=(0, 4), match='w123'>
<_sre.SRE_Match object; span=(0, 3), match='+12'>
<_sre.SRE_Match object; span=(0, 8), match='12345abc'>
<_sre.SRE_Match object; span=(0, 6), match='1ababc'>
<_sre.SRE_Match object; span=(0, 27), match='123dshaouiddfgiohsdoi fdhio'>
<_sre.SRE_Match object; span=(0, 13), match='hdsa23782jxld'>
<_sre.SRE_Match object; span=(0, 3), match='123'>
<_sre.SRE_Match object; span=(0, 9), match='abcabcabc'>
<_sre.SRE_Match object; span=(0, 6), match='9w3220'>
<_sre.SRE_Match object; span=(0, 0), match=''>
<_sre.SRE_Match object; span=(0, 2), match='ba'>
3.正则表达式符号的转义
- 特殊符号转义
正则中：. \ [] {} () * + ? ^ $ | 这些字符有意义，所以在正则表达式中，如果想要单纯表达这些字符，需要在前面加''
注意：
- [] ^ \ 在中括号可能更是特殊的符号,需要加\
- . {} () * + ? $ | 在括号中可以不用加\，来表示字符
import re
if __name__ == '__main__':
re_str = r'\d+\.\d'
print(re.fullmatch(re_str, '12.3'))
re_str = r'\d[1\-3]\d+'
print(re.fullmatch(re_str, '21344'))
re_str = r'[\^]' # 匹配 字符
# re_str = r'[\\]'
# re_str = r'[\$]'
# re_str = r'[{}]'
print(re.fullmatch(re_str, '{'))
# 1. \N ----> 匹配前面第N个组中匹配到的内容
re_str = r'([1-9][a-z]{2})n(\d)\1\2'
print(re.fullmatch(re_str, '9hjn09hj0'))
<_sre.SRE_Match object; span=(0, 4), match='12.3'>
<_sre.SRE_Match object; span=(0, 5), match='21344'>
None
<_sre.SRE_Match object; span=(0, 9), match='9hjn09hj0'>
练习1
用户名必须右字母，下划线或数字构成且长度在6-20个字符之间
QQ号是5~12位的数字且首位不能为0
uername = r'\w{6,20}'
print(re.fullmatch(uername,'chenpengh_123'))
uerid = r'[^0]\d{4,11}'
print(re.fullmatch(uerid,'894567221'))
<_sre.SRE_Match object; span=(0, 13), match='chenpengh_123'>
<_sre.SRE_Match object; span=(0, 9), match='894567221'>
ip地址的是否合法
ip=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(ip,'10.10.10.10'))
<_sre.SRE_Match object; span=(0, 11), match='10.10.10.10'>
4.re模块方法
import re
if __name__ == '__main__':
# 1. compile(正则字符串)将正则表达式字符串转换成正则表达式对象
# 转换成正则表达式对象后，可以通过对象调用相关的方法
re_obct = re.compile(r'\w{6,12}')
print(re_obct.fullmatch('ahsjjs'))
print(re.fullmatch(r'\w{6,12}','ahjhjs'))
# 2. fullmatch(正则表达式，字符串) ：完全匹配，从字符串开头匹配到结尾
# 返回这是匹配对象,如果失败返回None
match = re.fullmatch('\w{3}','h3s')
print(match)
# a.获取匹配到的结果
print(match.group())
# b. 获取匹配到的范围
print(match.span())
# c. 获取匹配到的开始下标和结束下标
print(match.start(),match.end())
# d.获取被匹配的原字符串
print(match.string)
# 应用：判断一个字符串是否是某种字符串（判断账号，密码是否符合要求）
# 3. match(正则表达式，字符串)不完全匹配，从字符串开头开始匹配，匹配到正则表达式对应的范围为止
# 返回值是匹配对象,如果失败返回None
match = re.match('\w{3}','h3siouio')
print(match)
print(match.group())
print(match.string)
# 应用：判断字符串是否以某一种字符串开头
# 4.search(正则表达式，字符串) 在指定的字符串中查找某种字符串（以正则表达式描述）
# 如果有多个，只匹配第一个
# 返回值是匹配对象,如果失败返回None
print(re.search(r'\d{2,}[a-z]','sha23n--877m0899'))
#应用：判断一个字符串中是否包含某种字符串
# 5. findall(正则表达式，字符串) 获取指定字符串中满足正则条件的所有子串
# 返回值是列表。列表中是，满足条件的字符串.没有满足就返回空的列表[]
result = re.findall(r'\D\d+\D','a123buye236oks')
print(result)
# 注意：在通过正则表达式获取子串的时候，可以通过在正则表达式中添加括号，来约束获取的内容（只捕获括号中匹配的内容）
# 匹配的时候还是按照原正则表达式取查找
result = re.findall(r'[a-zA-Z](\d+)', '12a123bu=236o98s')
print(result)
# 应用：字符提取
# 6. result = re.finditer(正则表达式，字符串) 用法和findall一样，只是返回值的类型不一样
# 返回值是一个迭代器，迭代器中的内容是匹配对象
# 注意：()捕获部分无效
result = re.finditer(r'[a-zA-Z](\d+)','12a123bu=236o98s')
for match in result:
print(match)
#print('ahsj27jkkajjsjsj',split('sj'))
# 7. re.split(正则表达式，字符串) 按正则表达式匹配到的字符串进行切割
# 返回值是列表，列表元素是切割之后被分段的字符串
result = re.split(r'\d+', 'ef234guyhg65yug3u4g')
print(result)
# 8.sub(正则表达式，新字符串，原字符串) 在原字符串中查找符合正则的子串，替换成新的字符串
# 将指定字符串中所有'sb'替换成'*'
str1 = "你好sb,你全家都是sb"
result = re.sub(r'sb','*',str1)
print(str1,result)
<_sre.SRE_Match object; span=(0, 6), match='ahsjjs'>
<_sre.SRE_Match object; span=(0, 6), match='ahjhjs'>
<_sre.SRE_Match object; span=(0, 3), match='h3s'>
h3s
(0, 3)
0 3
h3s
<_sre.SRE_Match object; span=(0, 3), match='h3s'>
h3s
h3siouio
<_sre.SRE_Match object; span=(3, 6), match='23n'>
['a123b', 'e236o']
['123', '98']
<_sre.SRE_Match object; span=(2, 6), match='a123'>
<_sre.SRE_Match object; span=(12, 15), match='o98'>
['ef', 'guyhg', 'yug', 'u', 'g']
你好sb,你全家都是sb 你好*,你全家都是*
