正则表达式re模块

匹配语法：

1、re.match     从第一个值匹配 只匹配一个就返回。
	re.match(pattern, string, flags=0)
	re.match('[0-9]','abc123') 匹配不到
	
 2、re.search    全局匹配，从头开始往后找， 只匹配一个就返回
 
	match 和 search 返回是一个对象，
	 re.match('[0-9]','123dasd') 
	#  <_sre.SRE_Match object; span=(0, 1), match='1'>    
	 re.search('[0-9]','abc1d3e') 
	 # <_sre.SRE_Match object; span=(3, 4), match='1'> 
	 
	需要先判断是否匹配到再取值，拿匹配到的结果用.group()
	res = re.search('[0-9]','abs1d2')
	if res:
	    print(res.group())  # 1
	    
3、 re.findall   把所有匹配到的字符放到以列表中返回，没有索引，匹配不到返回空列表。
	 re.findall('[0-9]','abc1d3e') 
	 #  ['1', '3']

4、 re.split     以匹配到的字符当做列表分隔符
5、re.sub       匹配字符并替换  
	
	re.sub(pattern, repl, string, count=0, flags=0)
	
	pattern : 正则中的模式字符串。
	repl : 替换的字符串，也可为一个函数。
	string : 要被查找替换的原始字符串。
	count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
	
6、re.fullmatch 全部匹配  
7、re.finditer
	和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
	re.finditer(pattern, string, flags=0)

常用的表达式规则：

'.'     默认匹配除\n之外的任意一个字符，
	若指定flag DOTALL,(re.S)则匹配任意字符，包括换行
	
'^'     匹配字符开头，若指定flags MULTILINE,(re.M)这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)
'$'     匹配字符结尾， 若指定flags MULTILINE(re.M) 	
		re.search('foo.$','foo1\nfoo2\n',re.MULTILINE).group() 会匹配到foo1

[...]	用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k'
[^...]	不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。

'*'     匹配*号前的字符0次或多次， 
		re.search('a*','aaaabac')  结果'aaaa'
'+'     匹配前一个字符1次或多次，
		re.findall("ab+","ab+cd+abb+bba") 结果['ab', 'abb']
'?'     匹配前一个字符1次或0次 ,
		re.search('b?','alex').group() 匹配b 0次
		? 等价于 {0,1}。
'{n}'   匹配前一个字符n次 ,
		re.search('b{3}','alexbbbs').group()  匹配到'bbb'
{ n,}	匹配 至少n个。
		例如， o{2,} 不能匹配"Bob"中的"o"，
		但能匹配 "foooood"中的所有o。
		"o{1,}" 等价于 "o+"。"o{0,}" 则等价于 "o*"。
'{n,m}' 匹配前一个字符n到m次，
		re.findall("ab{1,3}","abb abc abbcbbb") 结果'abb', 'ab', 'abb']

'|'     匹配|左或|右的字符，
		re.search("abc|ABC","ABCBabcCD").group() 结果'ABC'
'(...)' 分组匹配，分组匹配取结果可以用groups（），元祖返回。
		re.search('([a-z]+)([0-9]+)','a123').groups() == ('a', '123') 
'\A'    只从字符开头匹配，
'\Z'    匹配字符结尾，同$ 
'\d'    匹配数字0-9
'\D'    匹配非数字
'\w'    匹配[A-Za-z0-9]
'\W'    匹配非[A-Za-z0-9]
'\s'    匹配空白字符、\t、\n、\r ,
		 re.search("\s+","ab\tc1\n3").group() 结果 '\t'
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。

\B	匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。

'(?P<name>...)' 分组匹配
		 re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict() 
		 结果{'province': '3714', 'city': '81', 'birthday': '1993'}

特殊：

# | 需要转义
s='alex22jack23jinxin50|mack-oldboy'
re.split('\d+|\||-',s) == ['alex', 'jack', 'jinxin', '', 'mack', 'oldboy']  # | 需要转义
re.findall('\d+|\||-',s) = ['22', '23', '50', '|', '-'] 

# \比较特殊，加三个
s='alex22jack23jinxin50\mack-oldboy'  # \比较特殊，加三个
re.split('\\\\',s) == ['alex22jack23jinxin50', 'mack-oldboy']

# maxsplit=3
s='9-2*5/3+7/3*99/4*2998+10*568/14'
re.split('\W+',s) == ['9', '2', '5', '3', '7', '3', '99', '4', '2998', '10', '568', '14']
re.split('\W+',s,maxsplit=3) == ['9', '2', '5', '3+7/3*99/4*2998+10*568/14'] 
# maxsplit

#[]都包含，任意一个都可以
re.split('[-\*/\+]',s) == ['9', '2', '5', '3', '7', '3', '99', '4', '2998', '10', '568', '14']

# count
s = 'alex22jack23jinxin50\\mack-oldboy'
re.sub('\d+','_',s) == 'alex_jack_jinxin_\\mack-oldboy'
re.sub('\d+','_',s,count=2) == 'alex_jack_jinxin50\\mack-oldboy' 

# 全部匹配  慢 匹配的过程中，规则需要转换，需时间
re.fullmatch('\w+@\w+\.(com|cn|edu)','alex@oldboyedu.com') 

# compile先写规则再去匹配 快 规则转换1次转换好再去匹配
pattern = re.compile('\w+@\w+\.(com|cn|edu)') 
pattern.fullmatch('alex@oldboyedu.com') 

<_sre.SRE_Match object; span=(0, 18), match='alex@oldboyedu.com'>

# repl是函数的情况：

#!/usr/bin/python
# -*- coding: UTF-8 -*-
 
import re
 
# 将匹配的数字乘以 2
def double(matched):
    value = int(matched.group('value'))
    return str(value * 2)
 
s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s))

A46G8HFD1134

标识符

匹配语法是有标识符的，默认是0.

1、re.I   #忽略大小写  re.IGNORECASE
	re.search('a','All',re.I) == A 
2、re.M   #多行模式  re.MULTILINE
	re.search('foo.$','foo1\nfoo2\n') == foo2  
	re.search('foo.$','foo1\nfoo2\n',re.M) == foo1  
3、re.S   #改变.的行为，.是任意字符，除了换行符\n  加了之后匹配换行符
	re.search('.','\n') == None 
	re.search('.','\n',re.S) == \n  
4、re.X   #可对正则 规则 注释  re.VERBOSE 
	re.search('.','alex') == a 
	re.search('. #test','alex') == None
	re.search('. #test','alex',re.X) = a

注意：通过在 *、+ 或 ? 限定符之后放置 ?，该表达式从"贪心"表达式转换为"非贪心"表达式或者最小匹配。

s='<H1>Chapter 1 - 介绍正则表达式</H1>'
result=re.search('<.*?>',s)
print(result.group())
# <H1>
result=re.search('<.*>',s)
print(result.group())
# <H1>Chapter 1 - 介绍正则表达式</H1>