1、python中的正则表达式相关介绍
1.1 转义字符
注意使用原始字符串，以r开头的字符串，如r"python"；
当需要匹配 . \ * + 等特殊的字符时，需要在这些字符前加反斜杠\
例如：r"python\.org"用来匹配"python.org"
1.2数量词的贪婪模式与非贪婪模式
对于 * + ?这两个数量词，默认情况下是贪婪的（尽可能多的匹配字符）；
在 * + ? 后加?，就是非贪婪模式（尽可能少的匹配字符）；
对应的非贪婪模式是：*? +? ??
一般使用非贪婪模式
例如：
查找字符串"abbbc"
贪婪模式下：r"ab*" 将找到"abbb"
非贪婪模式：r"ab*?" 将只找到"a"
2、Python re模块
2.1 re模块的内容
compile(pattern[, flag]) #根据正则表达式创建匹配对象
match(pattern, string[, flag]) #在字符串的开始处进行匹配，返回matchObject或者None
search(pattern, string[, flag]) #在字符串中寻找模式，返回matchObject或者None
split(pattern, string[, maxsplit]) #根据模式的匹配项来分割字符串
findall(pattern, string[, flag]) #以列表的形式返回匹配的所有子串
finditer(pattern, string[,flag]) #返回一个顺序访问每一个匹配结果（matchObject）的迭代器
sub(pattern, repl, string[, count])
subn(pattern, repl, string[, count])
2.2 re.compile(pattern[, flag])
返回一个匹配模式对象，即pattern对象；
而后可以利用这个pattern对象来对字符串进行进一步的匹配操作；
flag是匹配模式，取值与解释如下：
re.I #忽略大小写
re.M #多行模式
re.S #点任意匹配模式
re.L #使预定义字符类 \w \W \b \B \s \S 取决于当前区域设定
re.U #使预定义字符类 \w \W \b \B \s \S 取决于unicode定义的字符属性
re.X #详细模式，正则表达式可以是多行的，忽略空白字符，可以加注释
2.3 re.match(pattern[, flag])
从string的开头开始匹配，如果成功返回一个matchObject，否则返回None
matchObject提供如下属性和方法，来获取匹配的子串的信息：
string 匹配时使用的文本
re 匹配时使用的pattern对象
pos 文本中正则表达式开始搜索的索引
endpos 最后一个被捕获的分组在文本中的索引，默认为None
lastgroup 最后一个被捕获的分组的别名，默认是None
group([group1, group2, ...])
获得一个或者多个分组截获的字符串；指定多个参数时，以元组形式返回；
group1可以使用编号也可以使用别名，其中编号0表示整个匹配的子串；
默认返回None
groups( ) 以元组的形式返回全部分组截获的字符串
groupdict( )返回以有别名的组的别名为键、以组截获的字符串为值的字典，不包含没有别名的。
start([group])
返回指定的组截获的字串在string中的开始索引，group默认为0
end([group])
返回指定的组截获的字串在string中的结束索引（最后一个字符索引+1），group默认为0
span([group])
返回(start([group]), end([group]))
expand(tmplate)
将匹配的分组带入tmplate中返回
例程：
import re
ptn = re.compile(r"(\w+) (\w+)(?P<sign>.*)")
m = ptn.match("hello world!")
print "m.string:", m.string
print "m.re:", m.re
print "m.pos:", m.pos
print "m.endpos:", m.endpos
print "m.lastindex:", m.lastindex
print "m.lastgroup:", m.lastgroup
print "m.group():", m.group()
print "m.group(1,2):", m.group(1, 2)
print "m.groups():", m.groups()
print "m.groupdict():", m.groupdict()
print "m.start(2):", m.start(2)
print "m.end(2):", m.end(2)
print "m.span(2):", m.span(2)
print r"m.expand(r'\g \g\g'):", m.expand(r'\2 \1\3')
输出：
m.string: hello world!
m.re: <_sre.SRE_Pattern object at 0x0000000002E96250>
m.pos: 0
m.endpos: 12
m.lastindex: 3
m.lastgroup: sign
m.group(): hello world!
m.group(1,2): ('hello', 'world')
m.groups(): ('hello', 'world', '!')
m.groupdict(): {'sign': '!'}
m.start(2): 6
m.end(2): 11
m.span(2): (6, 11)
m.expand(r'\g \g\g'): world hello!
2.4 re.search(pattern[, flag])
扫描整个string查找匹配，如果成功返回一个matchObject，否则返回None
2.5 re.split(pattern, string[, maxsplit])
按照能够匹配的字串将string分割，并返回列表，maxsplit用于指定最大分割次数
例程：
ptn = re.compile(r"\d+")
print ptn.split("one1two2three34four4")
输出：
['one', 'two', 'three', 'four']
2.6 re.findall(pattern, string[, flag])
搜索string，以列表形式返回全部能够匹配的子串
例程：
ptn = re.compile(r"\d+")
print ptn.findall("one1two2three34four4")
print ptn.findall("one1two2three34four4")
输出：
['1', '2', '34', '4']
2.7 re.finditer(pattern, string[, flag])
搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器
例程：
pattern = re.compile(r'\d+')
for m in re.finditer(pattern,'one1two2three3four4'):
print m.group(),
for m in re.finditer(pattern,'one1two2three3four4'):
print m.group(),
输出：
1 2 3 4
2.8 re.sub(pattern, repl, string[, count])
使用repl替换string中每一个匹配的字串后，返回替换后的字符串
1）当repl是一个字符串时，可以使用\id或者\g引用分组，但不能使用编号0
2）当repl是一个方法时，这个方法只接受一个matchObject对象作为参数，并放回一个字符串用于替换
count用于指定最多替换次数，不指定时全部替换
例程：
ptn = re.compile(r"(\w+) (\w+)")
s = "i say, hello world!"
print ptn.sub(r"\2 \1", s)
def func(m):
return m.group(1).title() + " " + m.group(2).title()
print re.sub(ptn, func, s)
s = "i say, hello world!"
print ptn.sub(r"\2 \1", s)
def func(m):
return m.group(1).title() + " " + m.group(2).title()
print re.sub(ptn, func, s)
输出：
say i, world hello!
I Say, Hello World!
2.9 re.subn(pattern, repl, string[, count])
返回(sub(pattern, repl, string[, count]), 替换次数)
3、正则表达式的语法规则
下面是Python中正则表达式的一些匹配规则
