标签：失败 index each pos lag 就是 strong 处理 对象
正则表达式并不是Python的一部分。正则表达式是用于处理字符串的强大工具，拥有自己独特的语法以及一个独立的处理引擎，效率上可能不如str自带的方法，但功能十分强大。得益于这一点，在提供了正则表达式的语言里，正则表达式的语法都是一样的，区别只在于不同的编程语言实现支持的语法数量不同；但不用担心，不被支持的语法通常是不常用的部分。如果已经在其他语言里使用过正则表达式，只需要简单看一看就可以上手了。
下图展示了使用正则表达式进行匹配的流程： 
正则表达式的大致匹配过程是：依次拿出表达式和文本中的字符比较，如果每一个字符都能匹配，则匹配成功；一旦有匹配不成功的字符则匹配失败。如果表达式中有量词或边界，这个过程会稍微有一些不同，但也是很好理解的，看下图中的示例以及自己多使用几次就能明白。
下图列出了Python支持的正则表达式元字符和语法： 
正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪的则相反，总是尝试匹配尽可能少的字符。例如：正则表达式"ab*"如果用于查找"abbbc"，将找到"abbb"。而如果使用非贪婪的数量词"ab*?"，将找到"a"。
与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\\"表示。同样，匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。
正则表达式提供了一些可用的匹配模式，比如忽略大小写、多行匹配等，这部分内容将在Pattern类的工厂方法re.compile(pattern[, flags])中一起介绍。
Python通过re模块提供对正则表达式的支持。使用re的一般步骤是先将正则表达式的字符串形式编译为Pattern实例，然后使用Pattern实例处理文本并获得匹配结果（一个Match实例），最后使用Match实例获得信息，进行其他的操作。
1 # -*- coding:utf-8 -*- 2 import re 3 4 # 将正则表达式编译成Pattern对象 5 pattern = re.compile(r‘hello‘) 6 7 # 使用Pattern匹配文本，获得匹配结果，无法匹配时将返回None 8 match = pattern.match(‘hello world!‘) 9 10 if match: 11 # 使用Match获得分组信息 12 print match.group() 13 14 ### 输出 ### 15 # hello
re.compile(strPattern[, flag]):
这个方法是Pattern类的工厂方法，用于将字符串形式的正则表达式编译为Pattern对象。 第二个参数flag是匹配模式，取值可以使用按位或运算符‘|‘表示同时生效，比如re.I | re.M。另外，你也可以在regex字符串中指定模式，比如re.compile(‘pattern‘, re.I | re.M)与re.compile(‘(?im)pattern‘)是等价的。
可选值有：
1 a = re.compile(r"""\d + # the integral part 2 \. # the decimal point 3 \d * # some fractional digits""", re.X) 4 b = re.compile(r"\d+\.\d*")
re提供了众多模块方法用于完成正则表达式的功能。这些方法可以使用Pattern实例的相应方法替代，唯一的好处是少写一行re.compile()代码，但同时也无法复用编译后的Pattern对象。这些方法将在Pattern类的实例方法部分一起介绍。如上面这个例子可以简写为：
1 m = re.match(r‘hello‘, ‘hello world!‘) 2 print m.group()
re模块还提供了一个方法escape(string)，用于将string中的正则表达式元字符如*/+/?等之前加上转义符再返回，在需要大量匹配元字符时有那么一点用。
Match对象是一次匹配的结果，包含了很多关于此次匹配的信息，可以使用Match提供的可读属性或方法来获取这些信息。
属性：
方法：
1 import re
2 m = re.match(r‘(\w+) (\w+)(?P<sign>.*)‘, ‘hello world!‘)
3
4 print "m.string:", m.string
5 print "m.re:", m.re
6 print "m.pos:", m.pos
7 print "m.endpos:", m.endpos
8 print "m.lastindex:", m.lastindex
9 print "m.lastgroup:", m.lastgroup
10
11 print "m.group(1,2):", m.group(1, 2)
12 print "m.groups():", m.groups()
13 print "m.groupdict():", m.groupdict()
14 print "m.start(2):", m.start(2)
15 print "m.end(2):", m.end(2)
16 print "m.span(2):", m.span(2)
17 print r"m.expand(r‘\2 \1\3‘):", m.expand(r‘\2 \1\3‘)
18
19 ### output ###
20 # m.string: hello world!
21 # m.re: <_sre.SRE_Pattern object at 0x016E1A38>
22 # m.pos: 0
23 # m.endpos: 12
24 # m.lastindex: 3
25 # m.lastgroup: sign
26 # m.group(1,2): (‘hello‘, ‘world‘)
27 # m.groups(): (‘hello‘, ‘world‘, ‘!‘)
28 # m.groupdict(): {‘sign‘: ‘!‘}
29 # m.start(2): 6
30 # m.end(2): 11
31 # m.span(2): (6, 11)
32 # m.expand(r‘\2 \1\3‘): world hello!
Pattern对象是一个编译好的正则表达式，通过Pattern提供的一系列方法可以对文本进行匹配查找。
Pattern不能直接实例化，必须使用re.compile()进行构造。
Pattern提供了几个可读属性用于获取表达式的相关信息：
1 import re
2 p = re.compile(r‘(\w+) (\w+)(?P<sign>.*)‘, re.DOTALL)
3
4 print "p.pattern:", p.pattern
5 print "p.flags:", p.flags
6 print "p.groups:", p.groups
7 print "p.groupindex:", p.groupindex
8
9 ### output ###
10 # p.pattern: (\w+) (\w+)(?P<sign>.*)
11 # p.flags: 16
12 # p.groups: 3
13 # p.groupindex: {‘sign‘: 3}
实例方法[ | re模块方法]：
1 # encoding: UTF-8 2 import re 3 4 # 将正则表达式编译成Pattern对象 5 pattern = re.compile(r‘world‘) 6 7 # 使用search()查找匹配的子串，不存在能匹配的子串时将返回None 8 # 这个例子中使用match()无法成功匹配 9 match = pattern.search(‘hello world!‘) 10 11 if match: 12 # 使用Match获得分组信息 13 print match.group() 14 15 ### 输出 ### 16 # world
1 import re 2 3 p = re.compile(r‘\d+‘) 4 print p.split(‘one1two2three3four4‘) 5 6 ### output ### 7 # [‘one‘, ‘two‘, ‘three‘, ‘four‘, ‘‘]
1 import re 2 3 p = re.compile(r‘\d+‘) 4 print p.findall(‘one1two2three3four4‘) 5 6 ### output ### 7 # [‘1‘, ‘2‘, ‘3‘, ‘4‘]
1 import re 2 3 p = re.compile(r‘\d+‘) 4 for m in p.finditer(‘one1two2three3four4‘): 5 print m.group(), 6 7 ### output ### 8 # 1 2 3 4
1 import re 2 3 p = re.compile(r‘(\w+) (\w+)‘) 4 s = ‘i say, hello world!‘ 5 6 print p.sub(r‘\2 \1‘, s) 7 8 def func(m): 9 return m.group(1).title() + ‘ ‘ + m.group(2).title() 10 11 print p.sub(func, s) 12 13 ### output ### 14 # say i, world hello! 15 # I Say, Hello World!
1 import re 2 3 p = re.compile(r‘(\w+) (\w+)‘) 4 s = ‘i say, hello world!‘ 5 6 print p.subn(r‘\2 \1‘, s) 7 8 def func(m): 9 return m.group(1).title() + ‘ ‘ + m.group(2).title() 10 11 print p.subn(func, s) 12 13 ### output ### 14 # (‘say i, world hello!‘, 2) 15 # (‘I Say, Hello World!‘, 2)
以上就是Python对于正则表达式的支持。熟练掌握正则表达式是每一个程序员必须具备的技能
标签：失败 index each pos lag 就是 strong 处理 对象
原文地址：https://www.cnblogs.com/klb561/p/10199421.html
