正则表达式讲解

# 关于Python中re模块使用
import re
'''
re模块对正则表达式的使用步骤一般有三步:
1、re.compile(正则表达式) 将正则表达式字符串编译为Pattern实例
2、用pattern实例去处理文本并获得匹配结果（比如一个Match实例）
3、然后用Match实例去获得信息
'''
# 这里先介绍几个常用的Pattern对象常用的方法：
pattern = re.compile(r'dsa')
mat = pattern.match('dsafwew2223')
mat2 = pattern.match('jjfdsafee')
mat3 = pattern.match('jjfdsafee',3)
# 1、注意这里的match(str,pos,endpos)这里pos和endpos代表匹配字符串的开头和结尾，默认是0和len(str)
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在子串的开头是可以匹配到的

#=================================================================

ser = pattern.search('erweadsafdsae')
# 2、search(str,pos,endpos)是查找整个字符串匹配找到的第一个
print(ser) # <_sre.SRE_Match object; span=(5, 8), match='dsa'>
print(ser.group()) # dsa

#====================================================================

pattern2 = re.compile(r'\d+')

lst = pattern2.findall("abc1def2rst3xyz")
# 3、findall(str,pos,endpos)这个方法是返回所有的子串并返回一个list
print(lst) # ['1', '2', '3']

#======================================================

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'>

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

#====================================================================

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

# 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')
#=============================================================

# 2、match.groups()： 返回由所有分组匹配到的字符串组成的 tuple。
m2 = re.match(r"(\d+)\.(\d+)", "24.1632")
print(m2.groups()) # ('24', '1632')

#================================================================

# 3、match.start()：没有参数时，返回匹配到的字符串的起始位置。指定参数（整数）时，返回该分组匹配到的字符串的起始位置。
print(m.start()) # 0
print(m.start(2)) # 5

#======================================================

# 4、match.end()：返回结束位置
print(m.end()) # 11
print(m.end(1)) # 4

#=============================================================

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

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

#==========================================================

#上面所说到的一些都是对象的函数，然而还有一些模块可以直接调用的函数
# 1、compile（）:上面介绍过了
# 2、match()
print(re.match('\w+','hehakhe_hdsfas').group()) # hehakhe_hdsfas
# 3、search（）
print(re.search(r"(\w+) (\w+)","Kobe Bryant, Lakers").group()) # Kobe Bryant
# 4、findall()
print(re.findall('\d+','hafu3uhaher432')) # ['3', '432']
# 5、finditer()
k = re.finditer('\d+','hfasui23ihw54552i') # k:<callable_iterator object at 0x0000000002B84A58>
for i in k:
print(i.group()) # 23 54552

#======================================================
'''
关于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*")
'''
#==============================================================

# re模块除了能搜索匹配字符串以外还可以修改字符串
# 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']

# 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）

转自：https://blog.csdn.net/three_co/article/details/78494977