匹配数字相关
'.' 默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行
'^' 匹配字符开头，若指定flags MULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
'$' 匹配字符结尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以
'*' 匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac") 结果为['abb', 'ab', 'a'],如果想控制一个组，可以加（）
'+' 匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
'?' 匹配前一个字符1次或0次，常用来表示可有可无（出现1次或0次）的一个符号
'{m}' 匹配前一个字符m次
'{n,m}' 匹配前一个字符n到m次，re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb'] ,可以替代'*' '+' '?' 为：｛0,｝ ｛1,｝ ｛0,1｝
'[]' 字符集，匹配[]中的字符（其中的字符是或的关系），其中的字符可以一一列出，也可以给出范围，元字符在其中失去意义，除非元字符前面加了反斜杠。有几种特殊的元字符依然有意义：表示范围的'-', 取反的'^',和'\'
>>> re.search('[a|b]','aabcd').group() # search方法在字符集匹配时只匹配一次
'a'
>>> re.search('[a|b]+','aabcd'). # '+' 匹配一次或多次字符集中的内容
'aab'
>>> re.findall('[a|b]','aabcd')
['a', 'a', 'b']
>>>
'|' 匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'
'(...)' 分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c。 分组匹配时，findall只返回分组括号中的内容，返回到一个列表，分组作用：为了在已经匹配到的内容中再去提取过滤内容，有几个括号就提取几次
'\' 1.后面跟元字符去除特殊功能，2.跟普通字符实现特殊功能(\d：匹配数字)，3.引用序号对应的字组所匹配的字符串
>>> re.search(r"(whisky)(\d+)com\2","whisky211985com211985").group()
'whisky211985com211985'
'\A' 效果和^是一样的，只从字符开头匹配，re.search("\Aabc","alexabc") 是匹配不到的
'\Z' 匹配字符结尾，同$
'\d' 匹配单个 数字0-9
'\D' 匹配非数字
'\w' 匹配[A-Za-z0-9]，注意：不能匹配空格、特殊字符等
'\W' 匹配非[A-Za-z0-9]
'\s' 匹配空白字符、\t、\n、\r、\f、\v, re.search("\s+","ab\tc1\n3").group() 结果 '\t'
‘\b’ 匹配一个单词边界，即单词和空格（或特殊字符）间的位置，字符串开头结尾及空格回车等的位置，不会匹配空格符本身
>>> import re
>>> re.findall('abc\b','asdas abc ')
[] # 没有声明原生字符串或转义，所以结果为空
>>> re.findall('abc\\b','asdas abc ')
['abc']
>>> re.findall(r'abc\b','asdas abc ')
['abc']
>>> re.findall(r'abc\b','asdas abc*')
['abc'] # 特殊字符作为单词边界 >>> re.findall(r'i\b','i miss iou')
['i']
>>> re.findall(r'i\b','imiss iou')
[]
>>> re.findall(r'\bi',' imiss iou') # 以空格为单词边界
['i', 'i']
>>> re.findall(r'\bi','imiss iou') #以字符串开头和空格为单词边界
['i', 'i']
例子
'(?P<name>...)' 分组匹配 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city") 结果{'province': '3714', 'city': '81', 'birthday': '1993'}
注意：?P为固定语法格式
写法：（?P<组名>正则表达式），输出（以字典的形式输出）：｛'组名'：'正则匹配的结果'｝
（*|+|？|｛｝）？ ： *、+、？、｛｝后面加？使用非贪婪模式
正则表达式中 .*? 代表什么？
解答：
点代表的是任意字符。* 代表的是取 0 至 无限长度问号代表的是非贪婪模式。三个链接在一起是取尽量少的任意字符，一般不会这么单独写。 用法：
他大多用在：.*?a 解释：
就是取前面任意长度的字符，到底一个 a 出现，匹配如下q@wer_qwerqweraljlkjlkjlkj， 得到：q@wer_qwerqwera 这部分，如果匹配不到后面的 a 字符，则匹配为空。
注意，re的若干方法：
match方法是从字符串开头往后匹配(用的少)
例：
res = re.match('^Chen', 'Chenronghua123') 语法：pattern，string
print(res)
#输出：<_sre.SRE_Match object; span=(0, 4), match='Chen'>
#res = re.match('r.+', 'Chen123ronghua123') #匹配结果为空，match从字符串开头开始匹配
# res = re.search('r.+', 'Chen123ronghua123') #search 从整个文本中搜索
# print(res.group())
# 结果：ronghua
#如果匹配不到返回None，即res为None，res.group()会报错
常用方法如下：
1.search是从整个文本中搜索,匹配到一个就返回
2.findall是从整个文本中搜索,贪婪匹配，如果匹配到多个全部返回,所有结果都放在一个列表中，findall没有group方法
>>> re.findall('[a-z]','wwwa.d')
['w', 'w', 'w', 'a', 'd']
>>> re.findall('[0-9]','w0w3w4a.99d')
['', '', '', '', '']
>>> re.findall('\d','w0w3w4a.99d')
['', '', '', '', '']
>>> re.findall('\d', 'aa22ww2qq123qwe333')
['', '', '', '', '', '', '', '', '']
>>> re.findall('\d\d', 'aa22ww2qq123qwe333')
['', '', '']
>>> re.findall('\d+', 'aa22ww2qq123qwe333')
['', '', '', '']
>>> re.findall('\w','w0w3w4a.99d')
['w', '', 'w', '', 'w', '', 'a', '', '', 'd']
>>> re.findall('\s','w0w3 w4a.99d')
[' ']
findall结合字符集例子
findall常和分组（）搭配使用，分组后利用findall方法只返回分组括号中的数据，爬虫常用，也可取消这种功能，例：
>>> re.findall('www.(?:baidu|123).com','asd www.baidu.com') # 在括号的组中加上'？：'即可匹配全部内容，而非仅是分组中的内容
['www.baidu.com']
findall的分组、无分组：
>>> string = 'hello sky asd sky age sky qwe 19w'
>>>
>>> r = re.findall('a\w+', string)
>>> print(r)
['asd', 'age']
>>> r = re.findall('a(\w+)', string) #此时findall作用相当于groups，但groups把结果放入元组，findall则放入列表中
>>> print(r)
['sd', 'ge']
>>>
>>> string = 'hello sky asd sky age sky qwe 19w'
>>> r = re.findall('(a)(\w+)', string)
>>> print(r)
[('a', 'sd'), ('a', 'ge')] # string从前到后每次匹配到的字符串都放入元组，所有匹配到的内容都放入列表
>>>
>>> r = re.findall('(s)(\w+)(y)', string) # 相当于把groups中的内容放到一起
>>> print(r)
[('s', 'k', 'y'), ('s', 'k', 'y'), ('s', 'k', 'y')] #每个组中都有一个元素，共三个元素
>>>
>>> string = 'hello whisky asd whisky age whisky qwe 19w'
>>> r = re.findall('(i)(\w+(k))(y)', string) #第一个元素是i 第二个：sk 第三个k 第四个：y，有几个括号就提取几次，取出的元素一次放入元组中，最后再把每次匹配的结果放入列表 ,另外，这里不支持re.findall('(i)(\w+(k))(？P<n1>y)', string)模版组名，用finditer可以支持
>>> print(r)
[('i', 'sk', 'k', 'y'), ('i', 'sk', 'k', 'y'), ('i', 'sk', 'k', 'y')]
>>>
>>> string = 'hello whisky asd whisky age whisky qwe 19w'
>>> r = re.finditer('(i)(\w+(k))(?P<n1>y)', string) # 迭代方式可匹配组名
>>> for i in r:
... print(i,i.group(),i.groups(),i.groupdict())
...
<_sre.SRE_Match object; span=(8, 12), match='isky'> isky ('i', 'sk', 'k', 'y') {'n1': 'y'}
<_sre.SRE_Match object; span=(19, 23), match='isky'> isky ('i', 'sk', 'k', 'y'){'n1': 'y'}
<_sre.SRE_Match object; span=(30, 34), match='isky'> isky ('i', 'sk', 'k', 'y'){'n1': 'y'}
>>>
findall 分组，无分组
findall：注意两个问题
1.findall无分组时匹配所有符合pattern的字符串
>>> n = re.findall('\d+\w\d+','a2b3c4d5')
>>> print(n)
['2b3', '4d5'] # 结果不是3c4，可知findall方法是从前向后逐个匹配，匹配到结果2b3，则去掉2b3，再继续向后匹配
>>> 2.匹配到空的内容会返回
>>> n = re.findall('','a2b3c4d5')
>>> print(n)
['', '', '', '', '', '', '', '', '']
>>> 3.指定分组次数时，因为只有一个括号（分组），所以只匹配最后一次内容
>>> a = 'whisky'
>>> n = re.findall('(\w)(\w)(\w)(\w)', a) #表示分4组，全部返回
>>> print(n)
[('w', 'h', 'i', 's')]
>>> n = re.findall('(\w){4}', a) # 表示拿分组取字符串中匹配4次
>>> print(n)
['s']
>>> 4. findall中的正则（如 *）会匹配到空，那么结果就会输出空，在开发时要避免正则表达式内容为空：
>>> n = re.findall('(\dasd)*','1asd2asdp3asd98kif')
>>> print(n)
['2asd', '', '3asd', '', '', '', '', '', ''] #*默认贪婪匹配，只有一个分组（括号），所以只返回2asd， *为空时，匹配结果为空，字符串最后默认有一个空字符，所以5个字符，匹配出6个空
>>>
>>> n = re.findall('(\dasd)+','1asd2asdp3asd4asd') #改为+，可以匹配想要的内容，不是输出空的结果
>>> print(n)
['2asd', '4asd'] # 因为只有一个括号分组，所以只返回4asd，没有3asd
findall 要注意的问题
>>> import re
>>> p = re.compile(r'\d+')
>>> w = p.finditer('12 qwesdad44ers running, 22 ... 11 ...')
>>> for match in w:
... match.group(),match.span()
...
('', (0, 2))
('', (10, 12))
('', (25, 27))
('', (32, 34))
finditer方法
小结：
findall其实就是一个一个的search，把search中的groups组合起来成为findall的内容，如果正则表达式中有一个分组，那么会去匹配组中的元素，放入列表；如果正则表达式中有多个组，会把组匹配到内容放到一个元组里面当作列表的一个元素，从前到后，重复此过程最后组成一个列表
3.match，group方法：
match 无分组：
>>> string = 'hello sky asd sky age sky qwe 19'
>>> r = re.match('h\w+',string)
>>> print(r.group()) # 获取匹配到的所有结果
hello
>>> print(r.groups()) # 只获取匹配到的分组结果
()
>>> print(r.groupdict()) # 获取匹配到的分组中所有执行了key的组
{}
>>> match 有分组（分组作用：提取匹配成功的指定内容。先匹配成功全部正则，再把匹配成功的局部内容提取出来）：
>>> string = 'hello sky asd sky age sky qwe 19'
>>> r = re.match('h(\w+)',string)
>>> print(r.group())
hello
>>> print(r.groups())
('ello',)
>>> print(r.groupdict())
{}
>>>
指定分组名，放入字典
>>> string = 'hello sky asd sky age sky qwe 19'
>>> r = re.match("(?P<n1>h)(?P<n2>\w+)",string)
>>> print(r.group())
hello
>>> print(r.groups())
('h', 'ello')
>>> print(r.groupdict())
{'n1': 'h', 'n2': 'ello'}
>>> 小结：
对于group方法，无论是否有分组，将会匹配正则表达式中匹配到的所有结果
对于groups方法，在有分组时，将匹配分组括号中（可以有多个分组）的内容，无分组则结果为空
对于groupdict方法，在有分组时，将匹配分组中所有执行了key的组。无分组则结果为空
写法：（?P<组名>正则表达式），输出（以字典的形式输出）：｛'组名'：'正则匹配的结果'｝，常用语jangle中的路由系统
无分组匹配时，上述三个方法，只有group有意义
4.split分隔方法
# split
# 无分组
string = 'hello sky ald qwe lge zxc 27'
n = re.split('s\w+', string)
print(n)
# 输出 ['hello ', ' ald qwe lge zxc 27'] # 有分组，split方法输出的结果如果用了分组，只保留分组中的内容
n = re.split('(s\w+)', string)
print(n)
# 输出 ['hello ', 'sky', ' ald qwe lge zxc 27']
n = re.split('s(\w+)', string)
print(n)
# 输出 ['hello ', 'ky', ' ald qwe lge zxc 27'] inpp = '1-2*((60-30 +(-40-5)*(9-2*5/3 + 7/3*99/4*2998 +10 * 568/14)) - (-4*3)/(16-3*2))'
n = re.split('\(([^()]+)\)', inpp) # 分割不含括号的最里层表达式，并去掉括号（表达式中转义符去匹配括号，里边括号作用split结果只取分组中的内容）
print(n)
# 输出 ['1-2*((60-30 +', '-40-5', '*', '9-2*5/3 + 7/3*99/4*2998 +10 * 568/14', ') - ', '-4*3', '/', '16-3*2', ')']
split 分组，无分组
4.sub替换方法
# sub不涉及分组
string = '1qqas2uuii234ashjd888kkasd333'
n = re.sub('\d+', '----', string)
print(n)
new_str, count = re.subn('\d+', 'KKK', string)
print(new_str, count) #输出：
----qqas----uuii----ashjd----kkasd----
('KKKqqasKKKuuiiKKKashjdKKKkkasdKKK', 5)
sub，subn方法
5.start（） 返回匹配开始的位置
end（） 返回匹配结束的位置
6.span（） 返回一个元组包含匹配（开始，结束）的位置 几个匹配模式：
1.re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
2.re.M(MULTILINE): 多行模式，改变'^'和'$'的行为（参见上图） [用得很少]
3.re.S(DOTALL): 使.匹配包括换行在内的所有字符，点任意匹配模式，改变'.'的行为
贪婪和非贪婪：
>>> re.search(r'a(\d+)','a3333333345b').group()
'a3333333345'
>>> re.search(r'a(\d+?)','a3333333345b').group()
'a3'
>>> re.search(r'a(\d*)','a3333333345b').group()
'a3333333345'
>>> re.search(r'a(\d*?)','a3333333345b').group()
'a' 如果分组括号两侧都有限制条件即：a（）b，则分组中的？非贪婪匹配不再起作用
>>> re.findall(r'a(\d+)b','a23b')
['']
>>> re.findall(r'a(\d+?)b','a23b')
['']
>>>
原生字符串：（字符串前面加r，即声明使用原生字符串）：
正则表达式中的r：（使用r前缀后，匹配字符串中所有字符都不转义，特殊字符不再有转义功能，只代表一个字符串）
r意思就是raw data，也就是原始数据，不用转义的。比如在一个字符串里面包含斜杠和一个字母n，"\n"就错了，这里的斜杠和n的组合在python中表示一个换行，必须"\\n"，也就是用反斜杠来转义反斜杠。但是用r后面接字符串就没这个问题了，r"\n"中的\n就是这两个个字母本身了。
>>> import re
>>> re.search(r"\\","ba\cabc").group()
'\\'
>>> re.search("\\","ba\cabc").group()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
>>> re.search(r"\\","ba\cabc").group()
'\\'
>>> re.findall("\\","ba\cabc")
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
>>> re.findall(r"\\","ba\cabc")
['\\']
注：
在python中，\n是换行，\r是回车，\b是退格
python中关于正则内的\b,为什么使用\b时需要用r'\b',但是\w则不需要？
解答：
因为\b 有两种解释，而\w 只有一种。 \b的两种解释是： 1.'\b', 如果前面不加r, 那么解释器认为是转义字符“退格键backspace”;
2.r'\b', 如果前面加r, 那么解释器不会进行转义，\b 解释为正则表达式模式中的字符串边界。 而相比于\b, \w 只有第二种解释，并没有对应的转义字符，所以不加r, 也不会出错。
问答
>>> import re
>>> re.findall('abc\b','asdas abc ') # 由于\b在python中表示退格，所以匹配不到内容
[]
>>> re.findall('abc\\b','asdas abc ') # 转义
['abc']
>>> re.findall(r'abc\b','asdas abc ') # 声明原生字符串，\b此时表示单词边界
['abc']
>>>
例子
split方法：
res = re.split('[0-9]+', 'abc12de3f45GH')
print(res)
输出：['abc', 'de', 'f', 'GH'] sub方法：
res = re.sub('[0-9]+', '|', 'abc12de3f45GH', count=2)
print(res)
输出：abc|de|f45GH 1.re.I(re.IGNORECASE): 忽略大小写
res = re.search('[a-z]+', 'abcGH', flags=re.I)
print(res.group())
输出：abcGH 2.M(MULTILINE): 多行模式，改变'^'和'$'的行为
res = re.search(r"^a", "\nabc\neee", flags=re.M)
print(res.group())
输出：a 3.S(DOTALL): 点任意匹配模式，改变'.'的行为
res = re.search(".+", "\nabc\neee", flags=re.S)
print(res.group())
输出：a 举例：
'.' 默认匹配除\n之外的任意一个字符，若指定flag DOTALL,则匹配任意字符，包括换行 res = re.match('.+', 'Chen123ronghua123')
print(res.group())
输出:
Chen123ronghua123 '$' 匹配字符结尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以 res = re.match('r.+', 'Chen123ronghua123') #匹配结果为空，match从字符串开头开始匹配
res = re.search('r.+', 'Chen123ronghua123') #search 从整个文本中搜索
print(res.group())
结果：ronghua '+' 匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
res = re.search('r[a-z]+a', 'Chen123ronghua123') #匹配ronghua
print(res.group())
结果：ronghua res = re.search('#.+#', '1123#hello#')
print(res.group())
结果：#hello# '?' 匹配前一个字符1次或0次
res0 = re.search('aal?', 'aalex')
res1 = re.search('aal?', 'aaex')
print(res0.group())
print(res1.group())
输出
aal
aa '{m}' 匹配前一个字符m次
res = re.search('[0-9]{3}', 'aa1xe2pp345lex') #匹配前面的数字三次
print(res.group()) '{n,m}' 匹配前一个字符n到m次
res = re.search('[0-9]{1,3}', 'aa1xe2pp345lex') #匹配前面的数字1到3次
print(res.group())
输出 1 findall 贪婪匹配
res = re.findall('[0-9]{1,3}', 'aa1xe2pp345lex') #findall,贪婪匹配，匹配前面的数字1到3次
print(res)
输出['1', '2', '345'] #以列表的形式返回 '|' 匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group() 结果'ABC' res = re.search('abc|ABC', 'ABCBabcCD')
print(res.group())
输出 ABC res = re.findall('abc|ABC', 'ABCBabcCD')
print(res)
输出 ['ABC', 'abc'] '(...)' 分组匹配，re.search("(abc){2}a(123|456)c", "abcabca456c").group() 结果 abcabca456c res = re.search('(abc){2}', 'alexabcabc')
print(res.group())
输出 abcabc res = re.search('(abc){2}(\|\|=){2}', 'alexabcabc||=||=') 匹配||= 两次，注意需要转义
print(res.group())
输出：abcabc||=||= '\D' 匹配非数字
res = re.search('\D+', '123$- a')
print(res.group())
输出：$- a '\w' 匹配[A-Za-z0-9] 除了特殊字符都匹配 res = re.search('\w+', '123$- a')
print(res.group())
输出：123 '\W' 匹配非[A-Za-z0-9] 只匹配特殊字符
res = re.search('\W+', '123$- ...a')
print(res.group())
输出：$- ... '\s' 匹配空白字符、\t、\n、\r , re.search("\s+","ab\tc1\n3").group() 结果 '\t'
res = re.findall('\s', '123$- \r\n\t...a')
print(res)
输出：[' ', '\r', '\n', '\t'] >>> re.search('\s+', '123$- \r\n')
<_sre.SRE_Match object; span=(5, 9), match=' \t\r\n'> '\A' 效果和^是一样的，只从字符开头匹配，re.search("\Aabc","alexabc") 是匹配不到的
'\Z' 匹配字符结尾，同$
'\d' 匹配数字0-9 例：
res = re.search('\A[0-9]+[a-z]\Z', '123a')
print(res.group())
输出:123a * : 0个至多个
+ ：1个至多个 res = re.match('^Chen\d+', 'Chen123ronghua123')
print(res)
print(res.group()) #查看匹配到的对象 输出：<_sre.SRE_Match object; span=(0, 7), match='Chen123'>
Chen123 '(?P<name>...)' 分组匹配
res = re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city")
print(res)
结果{'province': '3714', 'city': '81', 'birthday': '1993'}
