正则表达式：
正则表达式本身是一种小型的，高度专业化的编程语言，在python中，通过内嵌集成re模块
可以直接调用来实现正则匹配。
正则表达式本身是一种小型的，高度专业化的编程语言，在python中，通过内嵌集成re模块
可以直接调用来实现正则匹配。
动态的模糊匹配，存在一定的条件
例1:
import re
res = re.match("^Chen", "Chen321RongHua") #^匹配以Chen开头；
res1 = re.match("^Chen\d", "Chen321RongHua") #^匹配以Chen开头，\d其后为数字；
res2 = re.match("^Chen\d+", "Chen321RongHua") #^匹配以Chen开头，\d其后为数字， +代表一个或多个；
print(res.group())
print(res1.group())
print(res2.group())
输出：
Chen
Chen3
Chen321
功能函数：
1. re.compile()
编译正则表达式模式，返回一个对象模式；
可以把那些常用的正则表达式编译成正则表达式对象，提高一点效率；
格式：
re.complile(pattern, flags=0)
pattern: 编译时用的表达式字符串；
flags： 编译标志位，用于修正表达式的匹配方式，如：是否区分大小写，多行匹配等。
常用的flags有：
re.S(DOTALL): 使 . 匹配包括换行在内的所有字符；
re.I(IgnoreCase): 使匹配对大小写不敏感，即或略大小写
re.L(Locale): 做本地化识别（local-aware）匹配。
re.M(Multiline): 多行匹配，影响^和$
re.X(Verbose): 该标志通过给与更灵活的格式以便将正则表达式写得更易于理解；
re.U: 根据Unicode字符集解析字符，这个标志影响\w,\W,\b,\B
案例：
import re
tt = "This is a good girl, she is cool,clever, and so on....."
rr = re.compile(r"\w*oo\w*")
print(rr.findall(tt))
输出：['good', 'cool']
"\w" 匹配包括下划线在内的任何字符: [A-Za-z0-9_]
"*" 匹配前一个字符0次或多次
import re
tt = "This is a gOod girl, she is cool,clever, and so on....."
rr = re.compile(r"\w*oo\w*", re.I)
print(rr.findall(tt))
输出：['gOod', 'cool']
re.I(IgnoreCase): 使匹配对大小写不敏感，即或略大小写
2. re.match()
从字符串的开头开始匹配，返回第一个匹配的；
决定re是否在字符串刚开始的位置匹配，这个方法并不是完全匹配，当pattern结束时
若string还有剩余字符，仍然视为成功，要想完全匹配，可以在表达式末尾加上边界匹配符号"$"
格式：
re.match(pattern, string,flags)
案例：
print(re.match("com", "com www.baidu.com, www.test.Com").group())
print(re.match("com", "com www.baidu.com", re.I).group())
print(re.match(".*com", "www.baidu.com, www.test.Com").group())
输出：
com
com
www.baidu.com
一定时要从开头开始起匹配，否则匹配不上
3. re.search()
从字符串的任意位置开始匹配，返回第一个匹配的；
函数会在字符串内查找模式匹配，只要找到第一个匹配后就返回，如果字符串没有匹配，则返回None
格式：
re.search(pattern, string,flags)
案例：
print(re.search("com", "www.baidu.com, www.test.Com").group())
print(re.search("com", "om www.baidu.Com", re.I).group())
输出：
com
Com
备注：
match和search一旦匹配成功，就是一个match object对象，就以下方法：
group(): 返回被re匹配的字符串；
start(): 返回匹配的开始位置；
end(): 返回匹配的结束位置；
span(): 返回一个元组包含开始，结束的位置
groups(): 返回re整体匹配字符串，可以一次输入多个组号，对应的组号匹配的字符串
案例：
tt = "123abc456"
print(re.search("([0-9]*)([a-z]*)([0-9]*)", tt).group(0))
print(re.search("([0-9]*)([a-z]*)([0-9]*)", tt).group(1))
print(re.search("([0-9]*)([a-z]*)([0-9]*)", tt).group(2))
print(re.search("([0-9]*)([a-z]*)([0-9]*)", tt).group(3))
输出：
123abc456
123
abc
456
4. re.findall()
从字符串的任意位置开始匹配，返回所有匹配的； 没有group方法。
遍历匹配，可以获得字符串中所有的匹配的字符串，返回一个列表
格式：
re.findall(pattern, string,flags)
案例：
import re
tt = "This is a gOod girl, she is cool,clever, and so on....."
rr = re.compile(r"\w*oo\w*", re.I)
print(rr.findall(tt))
输出：
['gOod', 'cool']
5. re.split()
按照能够匹配的字符串将string分割后返回列表；
格式：
re.split(pattern,string[,maxsplit])
maxsplit 用于指定最大的分割次数，不指定全部分割
例如：
re.split(r"\S+", string) 将字符串按照空格分割一个单词列表
tt = "This is a gOod girl, she is cool,clever, and so on"
print(re.split(r"\s+", tt))
输出：
['This', 'is', 'a', 'gOod', 'girl,', 'she', 'is', 'cool,clever,', 'and', 'so', 'on']
案例：
>>> re.split("[0-9]", "abc12efg98sdsd343ksd")
['abc', '', 'efg', '', 'sdsd', '', '', 'ksd']
>>>
>>> re.split("[0-9]+", "abc12efg98sdsd343ksd")
['abc', 'efg', 'sdsd', 'ksd']
>>>
expr = "3*( 4+ 50 )-(( 100 + 40 )*5/2- 3*2* 2/4+9)*((( 3 + 4)-4)-4)"
>>> re.split(r"\(([^()]+)\)", expr,1)
['3*', ' 4+ 50 ', '-(( 100 + 40 )*5/2- 3*2* 2/4+9)*((( 3 + 4)-4)-4)']
6. re.sub():
使用re替换string中每一个匹配的字符串后返回匹配的字符串
格式：
re.sub(pattern, string, count)
案例：
>>> re.sub("[0-9]+", "|", "abc12ded87sds40hsd")
'abc|ded|sds|hsd'
>>>
>>> re.sub("[0-9]+", "|", "abc12ded87sds40hsd", count=2) #count表示需要替换的个数，不写表示替换所有
'abc|ded|sds40hsd'
>>>
常规的正则表达式符号：
1. "." 匹配任意除换行符"\n"外的字符(在DOTALL模式中也能匹配换行符);
>>> re.search("R.+Hua", "Chen321RongHua123").group()
'RongHua'
>>> re.search("R[a-zA-Z]+a", "Chen321RongHua123").group()
'RongHua'
>>>
>>> re.search("R[a-zA-Z]+a", "Chen321RongHua123RongHua").group()
'RongHua'
[0-9] #表示任何数字
[a-z] #表示匹配任意小写字母；
[A-Z] #表示匹配任意大写字母；
[a-zA-Z] #表示匹配任意大小写字母；
2. "^" 匹配字符串开头, 在多行模式中匹配每一行的开头;
3. "$" 匹配字符串末尾，在多行模式中匹配每一行的末尾
4. "*" 匹配前一个字符0次或多次
>>> re.search("hhh*", "hhello#1212") #至少匹配”hh"
<_sre.SRE_Match object; span=(0, 2), match='hh'>
>>>
5. "+" 匹配前一个字符1次或无限次
6. "?" 匹配前一个字符0次或1次
>>> re.search("hhh?", "hhello#1212") #至少匹配”hh"
<_sre.SRE_Match object; span=(0, 2), match='hh'>
>>>
7. "{m}" 匹配前一个字符m次，
>>> re.search("l{2}", "hhello#1212")
<_sre.SRE_Match object; span=(3, 5), match='ll'>
>>> re.search("[0-9]{3}", "hhello#1212")
<_sre.SRE_Match object; span=(7, 10), match='121'>
>>>
>>> re.search("[0-9]{4}", "hhello#1212")
<_sre.SRE_Match object; span=(7, 11), match='1212'>
>>> re.search("[0-9]{2}", "hhello#1212")
<_sre.SRE_Match object; span=(7, 9), match='12'>
>>>
8. {m,n} 匹配前一个字符m至n次，若省略n，则匹配m至无限次
>>> re.search("[0-9]{2,3}", "hhello#1212")
<_sre.SRE_Match object; span=(7, 10), match='121'>
>>>
>>> re.search("[0-9]{4,5}", "hhello#1212")
<_sre.SRE_Match object; span=(7, 11), match='1212'>
>>>
>>> re.search("[0-9]{5,6}", "hhello#1212")
>>>
>>>
>>> re.search("[0-9]{2,3}", "hhello#12")
<_sre.SRE_Match object; span=(7, 9), match='12'>
>>>
>>> re.search("[0-9]{2,3}", "hhe2w3l3lo#12")
<_sre.SRE_Match object; span=(11, 13), match='12'>
>>>
>>>
>>> re.findall("[0-9]{2,3}", "hhe2w3l3lo#12")
['12']
>>> re.findall("[0-9]{1,3}", "hhe2w3l3lo#12")
['2', '3', '3', '12']
>>>
9. "|" 或。匹配|左右表达式任意一个，从左到右匹配，如果|没有包括在()中，则它的范围是整个正则表达式
>>> re.search("abc|ABC", "hhabce2w3l3lABCo#12")
<_sre.SRE_Match object; span=(2, 5), match='abc'>
>>>
>>> re.findall("abc|ABC", "hhabce2w3l3lABCo#12")
['abc', 'ABC']
>>>
10. "(...)" 分组匹配。
>>> re.search("(abc){2}", "hhabcabc2w3l3lABCo#12abc") #匹配字符串abc的匹配次数
<_sre.SRE_Match object; span=(2, 8), match='abcabc'>
>>> re.search("abc{2}", "hhabcabcccccabc2w3l3lABCo#12abc") #只是匹配c匹配次数
<_sre.SRE_Match object; span=(5, 9), match='abcc'>
>>> re.search("(\|\|){2}", "hhabcabc2w3l3lABCo#12||||abc||")
<_sre.SRE_Match object; span=(21, 25), match='||||'>
11. "\" 转义字符，使后一个字符改变原来的意思
"\A" 只匹配字符串开头, 同^
"\Z" 只匹配字符串结尾， 同$
>>> re.search("\Ahh.+||\Z", "hhabcabc2w3l3lABCo#12||abc||")
<_sre.SRE_Match object; span=(0, 28), match='hhabcabc2w3l3lABCo#12||abc||'>
"\d" 匹配数字: [0-9]
"\D" 匹配非数字: [^0-9]
"\w" 匹配包括下划线在内的任何字符: [A-Za-z0-9_]
"\W" 匹配非字母字符，即匹配特殊字符 [^A-Za-z0-9_]
"\s" 匹配任何空白字符： <空格>\t,\n,\r,\f,\v
"\S" 匹配非空白字符： [^\s]
12. 正则表达式中中括号中可以表示
1. 某个区间内 如 [a-zA-Z0-9]
2. 某几个的范围 [abcd]
3. 可以在中括号中进行取非的操作. [^a]
4. 在中括号中的字符不再有特殊的含义 如经常匹配全部的 .和* [.][*]
>>> re.search("l{2}", "hhello#1212")
<_sre.SRE_Match object; span=(3, 5), match='ll'>
>>> re.search("[0-9]{3}", "hhello#1212")
<_sre.SRE_Match object; span=(7, 10), match='121'>
>>>
>>> re.search("[0-9]{4}", "hhello#1212")
<_sre.SRE_Match object; span=(7, 11), match='1212'>
>>> re.search("[0-9]{2}", "hhello#1212")
<_sre.SRE_Match object; span=(7, 9), match='12'>
>>>
8. {m,n} 匹配前一个字符m至n次，若省略n，则匹配m至无限次
>>> re.search("[0-9]{2,3}", "hhello#1212")
<_sre.SRE_Match object; span=(7, 10), match='121'>
>>>
>>> re.search("[0-9]{4,5}", "hhello#1212")
<_sre.SRE_Match object; span=(7, 11), match='1212'>
>>>
>>> re.search("[0-9]{5,6}", "hhello#1212")
>>>
>>>
>>> re.search("[0-9]{2,3}", "hhello#12")
<_sre.SRE_Match object; span=(7, 9), match='12'>
>>>
>>> re.search("[0-9]{2,3}", "hhe2w3l3lo#12")
<_sre.SRE_Match object; span=(11, 13), match='12'>
>>>
>>>
>>> re.findall("[0-9]{2,3}", "hhe2w3l3lo#12")
['12']
>>> re.findall("[0-9]{1,3}", "hhe2w3l3lo#12")
['2', '3', '3', '12']
>>>
9. "|" 或。匹配|左右表达式任意一个，从左到右匹配，如果|没有包括在()中，则它的范围是整个正则表达式
>>> re.search("abc|ABC", "hhabce2w3l3lABCo#12")
<_sre.SRE_Match object; span=(2, 5), match='abc'>
>>>
>>> re.findall("abc|ABC", "hhabce2w3l3lABCo#12")
['abc', 'ABC']
>>>
10. "(...)" 分组匹配。
>>> re.search("(abc){2}", "hhabcabc2w3l3lABCo#12abc") #匹配字符串abc的匹配次数
<_sre.SRE_Match object; span=(2, 8), match='abcabc'>
>>> re.search("abc{2}", "hhabcabcccccabc2w3l3lABCo#12abc") #只是匹配c匹配次数
<_sre.SRE_Match object; span=(5, 9), match='abcc'>
>>> re.search("(\|\|){2}", "hhabcabc2w3l3lABCo#12||||abc||")
<_sre.SRE_Match object; span=(21, 25), match='||||'>
11. "\" 转义字符，使后一个字符改变原来的意思
"\A" 只匹配字符串开头, 同^
"\Z" 只匹配字符串结尾， 同$
>>> re.search("\Ahh.+||\Z", "hhabcabc2w3l3lABCo#12||abc||")
<_sre.SRE_Match object; span=(0, 28), match='hhabcabc2w3l3lABCo#12||abc||'>
"\d" 匹配数字: [0-9]
"\D" 匹配非数字: [^0-9]
"\w" 匹配包括下划线在内的任何字符: [A-Za-z0-9_]
"\W" 匹配非字母字符，即匹配特殊字符 [^A-Za-z0-9_]
"\s" 匹配任何空白字符： <空格>\t,\n,\r,\f,\v
"\S" 匹配非空白字符： [^\s]
12. 正则表达式中中括号中可以表示
1. 某个区间内 如 [a-zA-Z0-9]
2. 某几个的范围 [abcd]
3. 可以在中括号中进行取非的操作. [^a]
4. 在中括号中的字符不再有特殊的含义 如经常匹配全部的 .和* [.][*]
>>> re.search("(?P<id>[0-9])","abcd1212sdsd121#we")
<_sre.SRE_Match object; span=(4, 5), match='1'>
>>>
>>> re.search("(?P<id>[0-9])","abcd1212sdsd121#we").group()
'1'
>>> re.search("(?P<id>[0-9]+)","abcd1212sdsd121#we").group()
'1212'
>>> re.search("(?P<id>[0-9]+)","abcd1212sdsd121#we").groupdict()
{'id': '1212'}
>>>
>>> re.search("(?P<id>[0-9]+(?P<name>[a-zA-Z]+))","abcd1212sdsd121#we").groupdict()
{'id': '1212sdsd', 'name': 'sdsd'}
>>>
>>> re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birth>[0-9]{8})", "362822198509160042").groupdict()
{'province': '3628', 'city': '22', 'birth': '19850916'}
>>>
匹配\： （需要用r且加\转义）
>>> re.search(r"\\", "abc\ss12\sd0\8999\aas")
<_sre.SRE_Match object; span=(3, 4), match='\\'>
>>>
>>>
>>> re.search(r"\\", "abc\ss12\sd0\8999\\aas")
<_sre.SRE_Match object; span=(3, 4), match='\\'>
>>>
>>>
>>> re.search(r"\\", "abc\\ss12\sd0\8999\\aas")
<_sre.SRE_Match object; span=(3, 4), match='\\'>
>>>
匹配忽略大小写：（flags = re.I）
>>> re.search("[a-z]+", "abc\ss12\sd0\8999\aas", flags=re.I)
<_sre.SRE_Match object; span=(0, 3), match='abc'>
>>> re.search("[a-z]+", "abc\ss12\sd0\8999\aas", flags=re.I).group()
'abc'
>>>
>>> re.search("[a-z]+", "aBc\Css12\sd0\8999\aas", flags=re.I)
<_sre.SRE_Match object; span=(0, 3), match='aBc'>
>>>
匹配多行模式：（re.M），改变"^"和"$"的行为；
>>> re.search(r"^a", "\nabc\neeee")
>>>
>>>
>>> re.search(r"^a", "\nabc\neeee",flags=re.M)
<_sre.SRE_Match object; span=(1, 2), match='a'>
>>>
>>>
点任意匹配模式，改变"."的行为，re.S
解释一下：
1.正则匹配串前加了r就是为了使得里面的特殊符号不用写反斜杠了。
2.[ ]具有去特殊符号的作用,也就是说[(]里的(只是平凡的括号
<_sre.SRE_Match object; span=(3, 4), match='\\'>
>>>
>>>
>>> re.search(r"\\", "abc\ss12\sd0\8999\\aas")
<_sre.SRE_Match object; span=(3, 4), match='\\'>
>>>
>>>
>>> re.search(r"\\", "abc\\ss12\sd0\8999\\aas")
<_sre.SRE_Match object; span=(3, 4), match='\\'>
>>>
匹配忽略大小写：（flags = re.I）
>>> re.search("[a-z]+", "abc\ss12\sd0\8999\aas", flags=re.I)
<_sre.SRE_Match object; span=(0, 3), match='abc'>
>>> re.search("[a-z]+", "abc\ss12\sd0\8999\aas", flags=re.I).group()
'abc'
>>>
>>> re.search("[a-z]+", "aBc\Css12\sd0\8999\aas", flags=re.I)
<_sre.SRE_Match object; span=(0, 3), match='aBc'>
>>>
匹配多行模式：（re.M），改变"^"和"$"的行为；
>>> re.search(r"^a", "\nabc\neeee")
>>>
>>>
>>> re.search(r"^a", "\nabc\neeee",flags=re.M)
<_sre.SRE_Match object; span=(1, 2), match='a'>
>>>
>>>
点任意匹配模式，改变"."的行为，re.S
解释一下：
1.正则匹配串前加了r就是为了使得里面的特殊符号不用写反斜杠了。
2.[ ]具有去特殊符号的作用,也就是说[(]里的(只是平凡的括号
