RE模块：Python编译正则的模块

#正则

元字符

表达式	匹配
.	小数点可以匹配除了换行符\n以外的任意一个字符
|	逻辑或操作符
[]	匹配字符集中的一个字符
[^]	对字符集求反，也就是上面的反操作。尖号必须在方括号里的最前面
-	定义[]里的一个字符区间，例如[a-z]
\	对紧跟其后的一个字符进行转义
()	对表达式进行分组，将圆括号内的内容当做一个整体，并获得匹配的值

转义字符\

1. 把原本的意义去掉。 “.”任意-----“\.”

2. 添加意义      “t”-----“\t”制表符

表达式	匹配
\r, \n	匹配回车和换行符
\t	匹配制表符
\\	匹配斜杠\
\^	匹配^符号
\$	匹配$符号
\.	匹配小数点.

预定义匹配字符

表达式	匹配
\d	任意一个数字，0~9中的任意一个
\w	任意一个字母或数字或下划线，也就是A~Z,a~z,0~9,_ 中的任意一个
\s	空格、制表符、换页符等空白字符的其中任意一个
\D	\d的反集，也就是非数字的任意一个字符，等同于[^\d]
\W	\w的反集，也就是[^\w]
\S	\s的反集，也就是[^\s]

#\d 匹配数字0-9

a= re.findall("\d","red84")

#print(a) #['8', '4']

#\D \d相反，\d不要的，\D要

a= re.findall("\D","red84")

#print(a) #['r', 'e', 'd']

#\w 匹配字母、数字、下划线

b= re.findall("\w","red84\nred79")

#print(b) #['r', 'e', 'd', '8', '4', 'r', 'e', 'd', '7', '9']

#\W \w的相反

b= re.findall("\W","red84\nred79")

#print(b) #['\n']

#\s 匹配空格、换行符、制表符

c = re.findall("\s","red84\nred79")

#print(c) #['\n']

#\S \s相反

c = re.findall("\S","red84\nred79")

print(c) #['r', 'e', 'd', '8', '4', 'r', 'e', 'd', '7', '9']

重复匹配

表达式	匹配
{n}	表达式重复n次，比如\d{2}相当于\d\d,a{3}相当于aaa
{m,n}	表达式至少重复m次，最多重复n次。比如ab{1,3}可以匹配ab或abb或abbb
{m,}	表达式至少重复m次，比如\w\d{2,}可以匹配a12,_1111,M123等等
?	匹配表达式0次或者1次，相当于{0,1}，比如a[cd]?可以匹配a,ac,ad
+	表达式至少出现1次，相当于{1,}，比如a+b可以匹配ab,aab,aaab等等
*	表达式出现0次到任意次，相当于{0,}，比如\^*b可以匹配b,^^^b等等

#{n} 匹配字符出出现n次

a = re.findall("l{2}","yellow")

#print(a) #['ll']

#{m,n} 匹配最少m次，最多n次

b= re.findall("l{2,4}","I like you,yellow,alllow,allll")

#print(b) #['ll', 'lll', 'llll']

#{m,} 至少是m次上不封顶

c= re.findall("l{2,}","yellow,alll,allll,alllll")

#print(c) #['ll', 'lll', 'llll', 'lllll']

#? 匹配0和1次

d = re.findall("l?","like,yellow")

#print(d) #['l', '', '', '', '', '', '', 'l', 'l', '', '', '']

#+ 至少出现1次

e = re.findall("l+","like,yellow")

#print(e) #['l', 'll']

# * 出现0次到任意次

f = re.findall("l*","like,yellow")

print(f) #['l', '', '', '', '', '', '', 'll', '', '', '']

位置匹配

表达式	匹配
^	在字符串开始的地方匹配，符号本身不匹配任何字符
$	在字符串结束的地方匹配，符号本身不匹配任何字符
\b	匹配一个单词边界，也就是单词和空格之间的位置，符号本身不匹配任何字符
\B	匹配非单词边界，即左右两边都是\w范围或者左右两边都不是\w范围时的字符缝隙

#  ^ 开头

a = re.findall("^1","18539334875")

print(a) #['1']

#  $ 结尾

b = re.findall("X$","44456789098765432X")

print(b) #['X']

贪婪模式/非贪婪模式

“贪婪模式”总是尝试匹配尽可能多的字符；

“非贪婪模式”则相反，总是匹配尽可能少的字符

a = re.findall(".","apple,orange,banaba")

print(a) #['a', 'p', 'p', 'l', 'e', ',', 'o', 'r', 'a', 'n', 'g', 'e', ',', 'b', 'a', 'n', 'a', 'b', 'a']

b = re.findall("^a","apple,orange,banaba")

print(b) #['a']

#re模块

定义

re模块是python独有的匹配字符串的模块，该模块中提供的很多功能是基于正则表达式实现的

常用方法

方法	描述	返回值
compile(pattern)	根据包含正则表达式的字符串创建模式对象	re对象
search(pattern, string)	在字符串中查找 。第一个匹配到的对象或者None	返回一个match对象
match(pattern, string)	在字符串的开始处匹配模式。 在字符串开头匹配到的对象或者None	返回一个match对象
findall(pattern, string,flags)	列出字符串中模式的所有匹配项	所有匹配到的字符串列表
finditer(pattern, string,flags)	将所有匹配到的项生成一个迭代器	所有匹配到的字符串组合成的迭代器
match.group(index)	将match对象拆分成字符串。不写index默认是0	返回match object中的字符串/元组
match.groups()	将match对象转换成元组	返回由所有分组匹配到的字符串组成的tuple。
match.start(index)	没有参数时，返回匹配到的字符串的起始位置。指定参数（整数）时，返回该分组匹配到的字符串的起始位置	返回int类型
match.end(index)	没有参数时，返回匹配到的字符串的结束位置。指定参数（整数）时，返回该分组匹配到的字符串的结束位置。	返回int类型
match.span(index)	返回一个二元tuple表示匹配到的字符串的范围，即(start, end)	返回元组
split(pattern, string)	根据模式的匹配项来分割字符串	分割后的字符串列表
sub(repl, string,count=0)	将字符串中所有的pat的匹配项用repl替换	完成替换后的新字符串
subn(pat,repl, string)	在替换字符串后，同时报告替换的次数	完成替换后的新字符串及替换次数
escape（string）	将字符串中所有特殊正则表达式字符串转义	转义后的字符串
purge(pattern)	清空正则表达式
template(pattern)	编译一个匹配模板	模式对象
fullmatch(pattern, string)	match方法的全字符串匹配版本	类似match的返回值

代码

查询模块

#compile(pattern)  根据包含正则表达式的字符串创建模式对象    re对象  
r = re.compile("[0-9]")
print(r) #返回一个编译正则的re对象
​
"""
re.IGNORECASE：忽略大小写，同 re.I。
re.MULTILINE：多行模式，改变^和$的行为，同 re.M。
re.DOTALL：点任意匹配模式，让'.'可以匹配包括'\n'在内的任意字符，同 re.S。
re.LOCALE：使预定字符类\w \W \b \B \s \S 取决于当前区域设定，同 re.L。
re.ASCII：使 \w \W \b \B \s \S 只匹配 ASCII 字符，而不是Unicode 字符，同 re.A。
re.VERBOSE：详细模式。
"""
import re 
b = re.compile(r"[a-w]",re.I)
a = b.findall("ADbcG")
print(a) #['A', 'D', 'b', 'c', 'G']
​
a = re.compile(r"""\d + # the integral part
                    \. # the decimal point
                    \d * # some fractional digits""", 
                    re.X)                
b = re.compile(r"\d+\.\d*")

#search(pattern, string)    在字符串中查找    第一个匹配到的对象或者None  
#扫描整个字符串，并返回它找到的第一个匹配（Match object）
r = re.compile("[0-9]")
a = r.search("123abc456")
print(a) #<re.Match object; span=(0, 1), match='1'>

#match(pattern, string) 在字符串开头匹配到的对象或者None      返回一个match对象  
r = re.compile("[0-9]")
a = r.match("123abc456") 
#a = r.match("123abc456")  #开头不是数字，所以输出None
print(a) #<re.Match object; span=(0, 1), match='1'>

#findall(pattern, string,flags)    列出字符串中模式的所有匹配项    所有匹配到的字符串列表     
r = re.compile("[0-9]")
a = r.findall("123abc4567")
print(a) #['1', '2', '3', '4', '5', '6', '7']

#  finditer(pattern, string,flags)    将所有匹配到的项生成一个迭代器   返回一个迭代器
r = re.compile("[0-9]")
a = r.finditer("123abc456")
print(a) #<callable_iterator object at 0x0000020C599BFA88>
print(list(a))
"""
[<re.Match object; span=(0, 1), match='1'>, 
<re.Match object; span=(1, 2), match='2'>, 
<re.Match object; span=(2, 3), match='3'>, 
<re.Match object; span=(6, 7), match='4'>, 
<re.Match object; span=(7, 8), match='5'>, 
<re.Match object; span=(8, 9), match='6'>]
"""

match相关方法

#match.group(index)将match对象拆分成字符串。不写index默认是0返回match object中的字符串  
"""
分组编号从1开始，从左往右，每遇到一个左括号，分组编号+1。
组0总是存在的，它就是整个表达式。
没有参数时，group1默认为0，这时返回整个匹配到的字符串。
"""
#空格不要忘了
r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you")
print(a)  #<re.Match object; span=(0, 6), match='I LOvE'>
print(a.group()) #I LOvE   默认是0
print(a.group(1)) #I
print(a.group(2)) #LOvE
print(a.group(3)) #报错
​
"""
 指定多个参数的时候，就返回一个元组
"""
print(a.group(1,2)) #('I', 'LOvE')
​
r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you")
print(a.groups()) #('I', 'LOvE')

#match.start(index)没有参数时，返回匹配到的字符串的起始位置。指定参数（整数）时，返回该分组匹配到的字符串的起始位置
r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you") 
print(a.start()) #0  
print(a.start(2)) #2  第二个单词的起始位置是2，下标从0开始
​
#match.end(index)
r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you") 
print(a.end()) #6
print(a.end(2)) #6
print(a.end(1))  #1

r = re.compile(r"(\w+) (\w+)")
a = r.match("I LOvE you") 
print(a.span()) #(0, 6)
print(a.span(1)) #(0, 1)
print(a.span(2)) #(2, 6)

拆分

#split(pattern, string)    根据模式的匹配项来分割字符串    分割后的字符串列表  
#意思是匹配到大写的字母就拆分
pattern = re.compile(r"[A-Z]+")
m = pattern.split("abcDefgHijkLmnoPqrs")
print(m) #['abc', 'efg', 'ijk', 'mno', 'qrs']

替换

"""       
sub(repl, string,count=0)   将字符串中所有的pat的匹配项用repl替换 |完成替换后的新字符串           |
repl可以是一个字符串，也可以是一个函数。
count用于指定最多替换次数，不指定时全部替换。
"""   
r = re.compile(r"like", re.I)
#s1 = r.sub(r"love", "I like you, do you like me?")  #I love you, do you love me?
#最多替换1次，所以把一个like替换了
s1 = r.sub(r"love", "I like you, do you like me?",count=1)
print(s1) #I love you, do you like me?
​
​
#subn(repl, string) | 在替换字符串后，同时报告替换的次数    | 完成替换后的新字符串及替换次数 |
#同sub()，只不过返回值是一个二元tuple，即(sub函数返回值，替换次数)。
r = re.compile(r"like", re.I)
"""
s1 = r.subn(r"love", "I like you, do you like me?")
print(s1) #('I love you, do you love me?', 2)
"""
s1 = r.subn(r"love", "I like you, do you like me?",count=1)
print(s1) #('I love you, do you like me?', 1)