Python-re模块

re模块的定义

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

re模块的常用方法

方法	描述	返回值
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)