Python中re模块的详细使用说明

1. re模块对正则表达式的使用步骤一般有三步:

    1、re.compile(正则表达式) 将正则表达式字符串编译为Pattern实例
    2、用pattern实例去处理文本并获得匹配结果（比如一个Match实例）
    3、然后用Match实例去获得信息。

Pattern对象方法总结

方法名称	re直接调用	pattern调用	说明	说明2
compile	re.compile('正则表达式')		返回Pattern实例
match	re.match('正则表达式',字符串)	pattern.match(字符串)	只能匹配开头	使用group(..)获得其中的内容
search	re.search('正则表达式',字符串)	pattern.search(字符串)	找到整个字符串匹配的第一个	使用group(..)获得其中的内容
findall	re.findall('正则表达式',字符串)	pattern.findall(字符串)	返回所有的子串并返回一个list
finditer	re.finditer('正则表达式',字符串)	pattern.finditer(字符串)	返回迭代器
split	re.split('正则表达式',字符串)	pattern.finditer(字符串)	返回list
sub	re.sub('正则表达式',repl, string, count=0)	pattern.sub(repl, string, count=0)	返回值
subn	re.subn('正则表达式',repl, string, count=0)	pattern.subn(repl, string, count=0)	返回一个tuple(返回值，替换次数)

 

 

 

 

 

 

 

 

 

 

match object常用方法

方法名称	参数说明	返回说明
group	match.group() 无参数或有参数
groups	无参数	返回由所有分组匹配到的字符串组成的 tuple
start	无参数或有参数	返回起始位置
end	无参数或有参数	返回结束位置
span	无参数或有参数	返回匹配字符串的范围

 

 

 

 

 

 

 

2. 这里先介绍几个常用的Pattern对象常用的方法：

2.1 注意这里的match(str,pos,endpos)这里pos和endpos代表匹配字符串的开头和结尾，默认是0和len(str)

import re
pattern = re.compile(r'dsa')
mat = pattern.match('dsafwew2223')
mat2 = pattern.match('jjfdsafee')
mat3 = pattern.match('jjfdsafee',3)
res = mat.group()
print(mat)  #   <_sre.SRE_Match object; span=(0, 3), match='dsa'>
print(res)  #   dsa
print(mat2) #   None 这里要注意match方法只能匹配开头
print(mat3) #   <_sre.SRE_Match object; span=(3, 6), match='dsa'> dsa在子串的开头是可以匹配到的

2.2 search(str,pos,endpos)是查找整个字符串匹配找到的第一个

ser = pattern.search('erweadsafdsae')  
print(ser)  #   <_sre.SRE_Match object; span=(5, 8), match='dsa'>
print(ser.group())  #   dsa

2.3 findall(str,pos,endpos)这个方法是返回所有的子串并返回一个list

pattern2 = re.compile(r'\d+')
lst = pattern2.findall("abc1def2rst3xyz")
print(lst)  #   ['1', '2', '3']

2.4 finditer(str,pos,endpos)找到所有匹配的子串，并返回由这些匹配结果（match object）组成的迭代器。

pattern3 = re.compile(r'\d+')
p = pattern3.finditer('abc1def2rst3xyz')
print(p)    #<callable_iterator object at 0x0000000002C5E780>是迭代器
for i in p:
    print(i)
#<_sre.SRE_Match object; span=(3, 4), match='1'>
#<_sre.SRE_Match object; span=(7, 8), match='2'>
#<_sre.SRE_Match object; span=(11, 12), match='3'>

3. 关于match object有几个常用的方法：

3.1 match.group（）：

返回 match object 中的字符串。

pattern4 = re.compile(r"(\w+) (\w+)")
m = pattern4.match("Kobe Bryant, Lakers")
print(m)               # <_sre.SRE_Match object; span=(0, 11), match='Kobe Bryant'>
print(m.group())       # Kobe Bryant
print(m.group(1))      # Kobe
print(m.group(2))      # Bryant
print(m.group(1, 2))   # ('Kobe', 'Bryant')

3.2 match.groups()：

返回由所有分组匹配到的字符串组成的 tuple。

m2 = re.match(r"(\d+)\.(\d+)", "24.1632")
print(m2.groups())   #   ('24', '1632')

3.3  match.start()：没有参数时，返回匹配到的字符串的起始位置。指定参数（整数）时，返回该分组匹配到的字符串的起始位置。

print(m.start())       # 0
print(m.start(2))      # 5

3.4 match.end()：返回结束位置

print(m.end())       # 11
print(m.end(1))      # 4

3.5 match.span([group])：返回一个二元 tuple 表示匹配到的字符串的范围，即 (start, end)。

print(m.span())     # (0, 11)
print(m.span(2))    # (5, 11)

4. 上面介绍了对象的函数，还有一些模块是类函数

4.1 compile():上面介绍过了

4.2 match()

print(re.match('\w+','hehakhe_hdsfas').group()) #   hehakhe_hdsfas

4.3 search()

print(re.search(r"(\w+) (\w+)","Kobe Bryant, Lakers").group())  #   Kobe Bryant

4.4 findall()

print(re.findall('\d+','hafu3uhaher432'))   #   ['3', '432']

4.5 finditer()

k = re.finditer('\d+','hfasui23ihw54552i')  # k:<callable_iterator object at 0x0000000002B84A58>
for i in k:
    print(i.group())   #    23  54552

5. re.compile()函数

关于re.compile() 函数：
    
    它还接受可选的第二个参数，用以设置匹配模式。
    
    可选的匹配模式有：
    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：详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。
    主要是为了让正则表达式更易读，同re.X。例如，以下两个正则表达式是等价的：
    a = re.compile(r"""\d +  # the integral part
                       \.    # the decimal point
                       \d *  # some fractional digits""", re.X)
    
    b = re.compile(r"\d+\.\d*")

6. re模块除了能搜索匹配字符串以外还可以修改字符串

6.1 split():

一种是用re模块直接调用，一种是pattern对象调用

pattern = re.compile(r"[A-Z]+")
g = pattern.split("abcDefgHijkLmnoPqrs")
print(g)    #   ['abc', 'efg', 'ijk', 'mno', 'qrs']
 
print(re.split(r"[A-Z]+","abcDefgHijkLmnoPqrs"))
#   ['abc', 'efg', 'ijk', 'mno', 'qrs']
 

6.2 sub()和subn():

与上面一样，一种是用re模块直接调用，一种是pattern对象调用。

sub和subn的区别在于subn返回的是一个二元tuple(返回值，替换次数)
pattern.sub(repl, string, count=0)：count代表替换次数
用 repl 替换 string 中每一个匹配的子串，返回替换后的字符串。若找不到匹配，则返回原字符串。

def fun(m):
    return m.group().upper()
 
pattern = re.compile(r"liKE", re.I)
s1 = pattern.sub(r"love", "I like you, do you like me?")
s2 = pattern.sub(fun, "I like you, do you like me?")
s3 = pattern.subn(r"love", "I like you, do you like me?")
s4 = pattern.subn(fun, "I like you, do you like me?",1)
print(s1)   #   I love you, do you love me?
print(s2)   #   I LIKE you, do you LIKE me?
print(s3)   #   ('I love you, do you love me?', 2)
print(s4)   #   ('I LIKE you, do you like me?', 1)
 
#   re.sub(pattern, repl, string, count=0, flags=0)：flags代表匹配模式
print(re.sub(r'liKE',r"love", "I like you, do you like me?",1,re.I))
#   I love you, do you like me?
print(re.subn(r'likE',r'love','I like you, do you like me?',3,re.I))
#   ('I love you, do you love me?', 2)