正则模块re,compile,search,findall,finditer,sub,subn,split函数,非贪婪匹配，r的作用

import re
#compile 函数
print("""
compile 函数
compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象。
从compile()函数的定义中，可以看出返回的是一个匹配对象，它单独使用就没有任何意义，需要和findall(), search(), match(）搭配使用。
re.compile(pattren[, flag])
pattern为一个字符串形式的正则表达式，flag是可选的，用于设置匹配模式，常见的几种匹配有

re.compile(r'\d+')			// 用于匹配数字
re.compile(r'[a-z]+')		// 用于小写字母
re.compile(r'[A-Z]+')		// 用于大写字母
……
re.compile(r'a.b')			// 符号“.”用来匹配除了换行符以外的任意字符
re.compile(r'a*b')			// 符号“*”前面的字符出现0次或以上（即以后面的字符为准）
re.compile(r'a.*b')			// 符号“.*”贪婪匹配：以a为开始以b为结束的所有内容
re.compile(r'a.*?b')			// 符号“.*?”非贪婪匹配：只要遇到以a为开始以b为结束就匹配
re.compile(r'a.*?(?=b)')		// 与上一条相同，区别在于：匹配结果不包括b


语法
prog = re.compile(pattern)
result = prog.match(string)

等价于
result = re.match(pattern, string)

https://blog.csdn.net/guo_qingxia/article/details/113979135
https://blog.csdn.net/m0_43609475/article/details/119924047
""")

print("""
compile()与match()一起使用，可返回一个class、str、tuple，dict。
""")
pattern = re.compile(r'\d+')
m = pattern.match('one12345678uhhhitwot34four',3,9) # 从下标3即数字1，匹配到下标9即数字7，下标从0开始。留头不留未，即'1'的位置开始匹配，匹配‘7’,最终结果为123456
print(m) #输出一个match对象
print(m.group()) #输出123456


#findall()
print("""
#findall()
compile()与findall()一起使用，返回一个列表。
""")

def main():
    content = 'Hello, I am Jerry, from Chongqing, a montain city, nice to meet you……'
    print("""
    #   \w 匹配数字字母下划线
    #   *   匹配前一个字符出现0次或多次
    #   （数字字母下划线0次或多次）o（数字字母下划线）
    """)
    regex = re.compile('\w*o\w*')
    x = regex.findall(content)
    print(x)
    print("""
    ['Hello', 'from', 'Chongqing', 'montain', 'to', 'you']
    """)
if __name__ == '__main__':
    main()

ret = re.findall(r"\d+", "python = 9999, c = 7890, c++ = 12345")
print(ret)
print("""
['9999', '7890', '12345']
""")

#re.search函数
print("""
#re.search函数
re.search 扫描整个字符串并返回第一个成功的匹配，如果没有匹配，就返回一个 None。
compile()与search()搭配使用, 返回的类型与match()差不多， 但是不同的是search(), 可以不从位置0开始匹配。但是匹配一个单词之后，匹配和match()一样，匹配就会结束。
""")

ret = re.search(r"\d+", "阅读次数为9999")
print(ret.group())
print("""
9999
""")

#re.finditer函数
print("""
和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
""")

it = re.finditer(r"\d+", "12a32bc43jf3")
for match in it:
    print(match.group())

print("""
12
32
43
3
""")

#re.sub函数
print("""
#re.sub函数
sub是substitute的所写，表示替换，将匹配到的数据进⾏替换。

语法：re.sub(pattern, repl, string, count=0, flags=0)

参数	    描述
pattern	必选，表示正则中的模式字符串
repl	必选，就是replacement，要替换的字符串，也可为一个函数
string	必选，被替换的那个string字符串
count	可选参数，count 是要替换的最大次数，必须是非负整数。如果省略这个参数或设为 0，所有的匹配都会被替换
flag	可选参数，标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。


""")

ret = re.sub(r"\d+", '998', "python = 997")
print(ret)
print("""
\d+ 匹配数字出现一次或多次
匹配字符串中的数字 并替换
把 python = 997  中的998 替换成 997
""")

def add(temp):
    print("""
    此处temp为
    第一个temp = re.search(r"\d+","python = 997")
    第二个temp = re.search(r"\d+","python = 99")
    """)
    #int（）参数必须是字符串，类似字节的对象或数字，而不是“re.Match”
    strNum = temp.group()
    num = int(strNum) + 1
    return str(num)
ret = re.sub(r"\d+", add, "python = 997")
print(ret)
ret = re.sub(r"\d+", add, "python = 99")
print(ret)

#re.subn函数
print("""
#re.subn函数
替换匹配成功的指定位置字符串,并且返回替换次数，可以用两个变量分别接受
subn(pattern, repl, string, count=0, flags=0)
# pattern： 正则模型
# repl   ： 要替换的字符串
# string ： 要匹配的被替换的字符串
# count  ： 指定匹配个数 次数
# flags  ： 匹配模式
""")


pattern = re.compile(r'(\w+) (\w+)')
s = 'i say, hello world!'
print(re.subn(pattern, r'\2 \1', s))
def func(m):
    return m.group(1).title() + ' ' + m.group(2).title()
print(re.subn(pattern, func, s))
### output ###
# ('say i, world hello!', 2)
# ('I Say, Hello World!', 2)


a,b=re.subn("a\w","替换","sdfadfdfadsfsfafsff") #替换匹配成功的指定位置字符串,并且返回替换次数，可以用两个变量分别接受
print(a) #返回替换后的字符串
print(b) #返回替换次数

print("""
sdf替换fdf替换sfsf替换sff""")
print("""3
""")

#re.split函数
print("""
#re.split函数
根据匹配进⾏切割字符串，并返回⼀个列表。

re.split(pattern, string, maxsplit=0, flags=0)

参数  	    描述
pattern	    匹配的正则表达式
string	    要匹配的字符串
maxsplit	分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数
""")

#匹配冒号或者空格，做切割
ret = re.split(r":| ","info:xiaoZhang 33 shandong")
print(ret)
print("""
['info', 'xiaoZhang', '33', 'shandong']
""")

#python贪婪和⾮贪婪
print("""
#python贪婪和⾮贪婪
Python⾥数量词默认是贪婪的（在少数语⾔⾥也可能是默认⾮贪婪），总是尝试匹配尽可能多的字符；⾮贪婪则相反，总是尝试匹配尽可能少的字符。
例如：正则表达式”ab*”如果用于查找”abbbc”，将找到”abbb”。而如果使用非贪婪的数量词”ab*?”，将找到”a”。
注：我们一般使用非贪婪模式来提取。

在"*","?","+","{m,n}"后⾯加上？，使贪婪变成⾮贪婪。
""")

#第一种
ss = "asdfghjk09089787"
print(re.match("a\w*",ss).group())         #贪婪匹配，匹配尽可能多的字符          #输出   asdfghjk09089787
print(re.match("a\w*?",ss).group(),'\n')   #非贪婪匹配， 匹配尽可能少的字符       #输出   a

print(re.match("a\w?",ss).group())          #贪婪匹配                         #输出    as
print(re.match("a\w??",ss).group(),'\n')    #非贪婪匹配                       #输出    a

print(re.match("a\w+",ss).group())          #贪婪匹配                       #输出   asdfghjk09089787
print(re.match("a\w+?",ss).group(),'\n')    #非贪婪匹配                     #输出   as

print(re.match("a\w{3,9}",ss).group())      #贪婪匹配                       #输出   asdfghjk09
print(re.match("a\w{3,9}?",ss).group(),'\n')#非贪婪匹配                     #输出   asdf

#第二种
print(re.match(r"aa(\d+)","aa2343ddd").group(1))
print(re.match(r"aa(\d+?)","aa2343ddd").group(1))
print(re.match(r"aa(\d+)ddd","aa2343ddd").group(1))
print(re.match(r"aa(\d+?)ddd","aa2343ddd").group(1))

#第三种提取图片地址
# . 匹配任意字符 除\n
test_str="<img data-original=https://www.abccdn.cn/appCovers/2016/11/13/1213973.jpg>"
ret = re.search(r"https://.*?.jpg", test_str)
print(ret.group())
print("""
https://www.abccdn.cn/appCovers/2016/11/13/1213973.jpg
""")

#r的作⽤
print("""
#r的作⽤
与大多数编程语言相同，正则表达式里使用”\”作为转义字符，这就可能造成反斜杠困扰。
假如你需要匹配文本中的字符”\”，那么使用编程语言表示的正则表达式里将需要4个反斜杠”\\\\”：
前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。
Python里的原生字符串很好地解决了这个问题，Python中字符串前⾯加上 r 表示原⽣字符串。
""")
mm = "c:\\a\\b\\c"
print(mm)#c:\a\b\c
ret = re.match("c:\\\\",mm).group()
print(ret)#c:\
ret = re.match("c:\\\\a",mm).group()
print(ret)#c:\a
ret = re.match(r"c:\\a",mm).group()
print(ret)#c:\a
#ret = re.match(r"c:\a",mm).group() #匹配结果c:a,不存在
#print(ret)#AttributeError: 'NoneType' object has no attribute 'group'

参考：
https://blog.csdn.net/guo_qingxia/article/details/113979135
https://blog.csdn.net/m0_43609475/article/details/119924047