1.正则表达式
1.什么是正则表达式
正则表达式就是一个字符匹配的工具；是由正则符号和普通字符组成，来匹配不同规律的字符串
2.python对正则表达式的支持
python中内置提供了一个re模块，用来支持正则表达式
fullmach（正则表达式，字符串） - 用正则表达式去完全匹配字符串，如果匹配成功，返回一个匹配结果；
失败，返回None
python中正则表达式的写法：将正则内容写到字符串中，一般这个字符串最前面会加一个r
1 普通字符
普通字符在正则表达式中，代表字符本身
import re
#匹配一个字符串，第一个字符是a，第二个字符是b，第三个字符也是最后一个字符是c
re_str = r"abc"
result=re.fullmatch(re_str,"abc") # <re.Match object; span=(0, 3), match='abc'>
print(result)
2 . (匹配任意字符)
在正则表达式中，.出现的位置，可以匹配一个任意字符
注意：一个.只能匹配一个字符
import re
#匹配一个字符串长度为3，并且第一个字符是a，最后一个字符为c，中间为任意字符的字符串
re_str =r"a.c"
result =re.fullmatch(re_str,"a\tc")
print(result) #<re.Match object; span=(0, 3), match='a\tc'>
3 \w(匹配字母数字或者下划线)
在正则表达式中，\w出现的位置可以匹配一个任意的字母数字、下划线(其实也可以匹配Unicode编码中除了ASCII码剩下的部分)
注意：
一个\w只能匹配一个字符
中文也可以匹配
import re
re_str = r"\w..."
result =re.fullmatch(re_str,"1&5%") #<re.Match object; span=(0, 4), match='1&5%'>
result1 =re.fullmatch(re_str,"啊333") #<re.Match object; span=(0, 4), match='啊333'>
print(result)
print(result1)
4 \s （匹配空白字符）
空白字符包括：空格、制表符和换行符
注意：一个\s只能匹配一个字符
import re
#匹配一个长度是4的字符串，并且字符串前两位是字母数字下划线，中间一个空白，最后是字符数字下划线的字符串。
re_str =r"\w\w\s\w"
result =re.fullmatch(re_str,"hj\n8") #<re.Match object; span=(0, 4), match='hj\n8'>
result1 =re.fullmatch(re_str,"hj\r8")
print(result1)
5 \d （匹配数字字符）
#匹配一个长度为5的字符串，并且字符串前三位必须是数字字符，后两位是任意字符
re_str = r"\d\d\d.."
result =re.fullmatch(re_str,"555aa")
print(result)
6 \b(检测单词边界)
注意：\b：是检测\b出现的位置是否是单词边界，不会对字符进行匹配。
当正则表达式中出现了\b，匹配的时候先去掉\b，匹配成功后，再看\b出现的位置是否是单词边界
单词边界：单词开头，单词结尾、标点符号、空白符号等（只要能将单词区分开的符号都属于单词边界）
#匹配字符串”hello world ， 并且要求w的前面是单词边界“
re_str =r"hello\b world"
result =re.fullmatch(re_str,"hello world")
print(result)
7 ^ （检测字符串开头）
在match与fullmatch中没有意义，search、findall等中有意义
import re
#匹配一个字符串长度为5，前面三个字符是the，后面两个任意字符
re_str = r"^The.."
8 $ （检测字符串结尾）
在match与fullmatch中没有意义，search、findall等中有意义
re_str =r"The$"
result =re.fullmatch(re_str,"The")
print(result)
\大写字母对应的功能是\小写字母的取反
例如：
\w - 匹配数字、字母、下划线
\W - 匹配非数字、字母、下划线
\D - 匹配非数字字符
\S - 匹配非空白字符
\B - 检测非单词边界
9 \W （匹配非数字、字母、下划线)
# 匹配一个字符串，第一个字符是数字，第二个是非数字，
# 第三个是空白字符,第四个是数字字母下划线，最后一个是a，并且要求a的前面不是单词边界
re_str =r"\d\D\s\w\Ba"
result =re.fullmatch(re_str,"1b _a")
print(result) #<re.Match object; span=(0, 5), match='1b _a'>
10 [ 字符集] (匹配中括号出现的任意一个字符)
1.[普通字符集] (匹配中括号出现的任意一个字符)
列如：[abc] - 匹配a或者b或者c
注意：a.一个中括号只能匹配一个字符
b.正则中有特殊功能的单个符号放在中括号中会失效，例如：. $等
c.匹配字符的组合符号在中括号中保持原来的功能；列如：\w，\d等
import re
#匹配一个长度是2的字符串，并且第一个字符为数字，第二个字符为[bcd=]里面的元素
re_str =r"\d[bcd=]"
result =re.fullmatch(re_str,"1=")
print(result)
2.[字符1-字符2] - 表示字符1-字符2的范围（字符1的编码值，要小于字符2的编码）
[a-z] - 表示匹配所有的小写字母
[A-Z] - 表示匹配所有的大写字母
[a-zA-Z] - 表示匹配所有的字母
[1-7] - 匹配数字字符1到7
[\u4e00-\u9fa5] - 匹配所有中文
import re
re_str =r"[a-z]"
11 [^字符集] - （匹配不在字符集中的任何字符）
[^abc] - 匹配除了abc以外的任意其他字符
[^a-z] - 匹配除了小写字母外的其他任意字符
2.正则控制匹配次数
1. * (匹配0次或者多次)
a* - a出现0次或多次
\d* - 任意数字出现0次或者多次，"","1","1212"...都可以匹配
[abc]* - a、b或c出现0次或者多次
注意：在[]外面的*的前面需要一个字符，或者一个匹配字符的符号
import re
print(re.fullmatch(r"a*b","aaab"))
print(re.fullmatch(r"[abc]*","aaab"))
print(re.fullmatch(r".*","sdasda32&_12%#@$说到底"))
2. + （匹配1次或者多次）
a+ -a至少出现一次
3.? (匹配0次或者一次)
a? - a出现0次或者一次，"","a"可以匹配
import re
#写一个正则表达式，匹配一个整数（正负都可以），例如：123,10，+100，-123
re_str =r"[+-]?[1-9]\d*"
result =re.fullmatch(re_str,"+1")
print(result)
4 {}
{N} - 匹配N次，a{3} - 匹配a出现三次,"aaa"
{M,N} - 匹配M-N次，M<N,a{3,5}，匹配"aaa","aaaa","aaaaa"
{,N} - 最多匹配N次（0~N）例如：a{，3} ，"","a","aa","aaa"
{M,} - 最少匹配M次（M~*）例如：a{3,},"aaa","aaaa"...
#练习：输入密码，要求检测密码输入是否合格（密码由字母和数字组成，数字不开头，6~12位）
# 输入正确就是正确，错误就提示错误
re_str =r"[a-zA-Z][a-zA-Z\d]{5,11}"
password =input("请输入密码：")
result =re.fullmatch(re_str,password)
if not result:
print("密码格式错误")
else:
print("输入正确")
3.分之、捕获贪婪
1.分之
条件1 | 条件2 - 匹配条件1或者条件2
\d | [a-z] - 匹配数字或者小写字母
a\d{2} | \w{2} - 匹配一个a后面两个数字，或者两个数字字母下划线
注意：正则中的分之也会出现短路，当条件1可以匹配，就不会再使用条件2进行匹配
import re
print(re.fullmatch(r"\d{2}|[a-z]","22"))
print(re.fullmatch(r"a\d{2}|\w{2}","a23"))
#练习：写一个正则表达式，匹配所有的数字，包括正的，负的，整数，小数，0
re_str =r"[+-]?0[.]\d*|[+-]?[1-9]\d*[.]?\d*"
result =re.fullmatch(re_str,"-0.1212")
print(result)
2.捕获和分组
a.分组 - 将括号里面的内容作为一个整体
b.捕获:
re.findall（正则表达式，字符串） -在字符串中获取符号正则表达式条件的所有子串
返回的是一个列表
通过正则去获取符号条件的子串的时候，可以在正则表达式中加括号，匹配后只获取括号里面的内容
import re
#=============分组==============
# 匹配一个字符串，前三位是‘abc’，后三位是三个数字或者三个大写字母
re_str =r"abc\d{3}|abc[A-Z]{3}"
re_str1 =r"abc(\d{3}|[A-Z]{3})"
#匹配一个字符串，以“数字小写字母”的形式出现三次
re_str =r"(\d[a-z]){3}"
#=============捕获=============
str1 ="asda1218a5d54ea2323dd"
print(re.findall(r"a\d+",str1)) # ['a1218', 'a5', 'a2323']
#取值的时候只取括号里面的内容
print(re.findall(r"a(\d+)",str1))# ['1218', '5', '2323']
"""
c.重复匹配
带多个分组的正则表达式中可以在分组的后面通过添加 \数字 来重复前面第几个分组中匹配到的内容
注意：重复的内容必须一致
"""
# 说明：\数字 - 这儿的数字代表前面第几个分组；\1代表第一个分组
re_str =r"\d{3}([a-z]{2})a-\1"
print(re.fullmatch(re_str,"123cea-ce"))
3.贪婪
匹配次数后加？就是贪婪匹配：*？ +？ ？？ {M,N}？ {M,}? 表示尽可能少的重复
import re
re_str = "a.+?b"
str1 ="xxxahhhdbhjahjbhjee"
print("====",re.findall(re_str,str1)) #['ahhhdb', 'ahjb']
4.转义字符
在正则表达式中可以在有特殊意义或者特殊功能的符号前加\来取消其特殊功能或者意义
- \\w - 代表两个字符是“\”和w
- \+ - 代表+字符
- [],(),{} 表示字符的时候，前面也要加\
注意：在[]中，\必须加\表示\本身，^和-也要加\，表示其本身
4.re模块
1.compile
compile(正则表达式) - 将正则表达式转换成正则表达式对象
import re
re_str="\d{3}"
re_obj =re.compile(re_str)
#调用模块中的函数
print(re.fullmatch(re_str,"211"))
#调用对象方法
print(re_obj.fullmatch("234"))
2.match和fullmatch
a.fullmatch(正则表达式，字符串) - 完全匹配，从开头到字符串结束
b.match(正则表达式，字符串)- 不完全匹配，只匹配字符串开头
匹配成功就返回匹配对象，匹配失败就返回None
import re
re_str = r"\d([A-Z]{2})"
print(re.fullmatch(re_str,"1IN"))
result=re.match(re_str,"1IN56565")
print(result)
匹配对象
- 1.获取span值 - 匹配到的内容的范围，（开始下标，结束下标）
匹配对象.span（）获取整个正则表达式匹配到的范围
匹配对象.span（n）获取正则表达式中第n个分组匹配到的范围（前提是要有分组）import re result=re.match(re_str,"1IN56565") print(result.span(1)) #(1, 3) - 2.start和end - 获取匹配结果的开始下标和结束下标
匹配对象.start()/匹配对象.end() -获取整个正则表达式的开始下标和结束下标
匹配对象.start(n)/匹配对象.end(n) - 获取正则表达式中第n个分组匹配到的开始下标和结束下标result=re.match(re_str,"1IN56565") print(result.start(),result.end()) #0 3 print(result.start(1),result.end(1)) #1 3 - 3.group - 获取匹配到的内容
匹配对象.group（） - 获取整个正则表达式匹配到的内容
匹配对象.group（n） -获取正则表达式中第n个分组匹配到的内容result=re.match(re_str,"1IN56565") print(result.group()) #1IN print(result.group(1)) #IN - 4.string - 获取用来匹配的原字符串
匹配对象.stringimport re result=re.match(re_str,"1IN56565") print(result.string) #1IN56565
3.search
search（正则表达式，字符串）- 匹配字符串中第一个满足正则表达式的子串，如果匹配成功，返回匹配对象，否则返回None
import re
str1 ="abc123hks362abc123"
result =re.search(r"\d{3}[a-z]{2}",str1)
print(result)
4.spilt
split(正则表达式，字符串) - 在字符串中按照满足正则表达式的子串进行切割
import re
str1 ="abds1sd5sdss8dsd4545d2dd"
result =re.split(r"\d+",str1)
print(result) #['abds', 'sd', 'sdss', 'dsd', 'd', 'dd']
5.sub
sub（正则表达式，新子串，字符串） -在字符串中用新子串替换满足正则表达式中的子串，返回新字符串
import re
str1 ="草你麻痹的 你是sb吗"
result =re.sub(r"[草麻痹]|sb","*",str1)
print(result)
6.findall
findall(正则表达式，字符串) - 在字符串中获取满足正则表达式的所有字符，返回的是一个列表，列表元素是字符串
注意：如果正则表达式中有一个分组，结果就是列表中只取分组对应的字符串
如果正则表达式中的分组大于1，列表中的元素是元组，每个元组的元素就是每个分组匹配到的内容
import re
str1 ="asd5eeaaaadee8787qwaadsd12aasd1212dsdse==33"
result =re.findall(r"[a-zA-Z]{2,}\d+[a-z]+?",str1)
print(result) #['asd5eeaaaadee', 'qwaadsd12aasd']
#['asd5e', 'eaaaadee8787q', 'waadsd12a', 'asd1212d']
7.finditer
finditer（正则表达式，字符串）-获取字符串满足正则表达式的内容，返回的是一个迭代器，迭代器中的元素就是匹配到的对象
result =re.finditer(r"[a-zA-Z]{2,}\d+[a-z]+?",str1)
print(next(result))
print(next(result))
#思考：写一个自己的finditer
def my_finditer(pattern,string):
re1 =re.search(pattern,string)
while re1:
yield re1
string =string[re1.end():]
re1 =re.search(pattern,string)
result=my_finditer(r"[a-zA-Z]{2,}\d+[a-z]+?",str1)
print(next(result))
print(next(result))
