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


以上，如有不足欢迎指教！Thanks~!