<span style="font-size:18px;">>>> S = '100BROAD200'
>>> re.sub(r'bROADb','RD',S)
#当ROAD不在末尾时，上面的匹配就会失败，所以在这里给ROAD的前后都加上b（单词边界），这样就能匹配整个字符串中的所有的ROAD了。神奇有木有
'100BROAD200'
>>> S = '100 BROAD 200'
>>> re.sub(r'bROADb','RD',S)
'100 BROAD 200'
>>> S = '100 BROAD ROAD
200'
>>> re.sub(r'bROADb','RD',S)
'100 BROAD RD
200'</span>

一些Python 的RE方法及其应用(https://docs.python.org/2/library/re.html)

<span style="font-size:18px;">>>> import re
>>> help (re)
This module exports the following functions:</span>

<span style="font-size:18px;">        match    Match a regular expression pattern to the beginning of a string.
        search   Search a string for the presence of a pattern.
        sub      Substitute occurrences of a pattern found in a string.
        subn     Same as sub, but also return the number of substitutions made.
        split    Split a string by the occurrences of a pattern.
        findall  Find all occurrences of a pattern in a string.
        finditer Return an iterator yielding a match object for each match.
        compile  Compile a pattern into a RegexObject.
        purge    Clear the regular expression cache.
        escape   Backslash all non-alphanumerics in a string.
    
    Some of the functions in this module takes flags as optional parameters:
        I  IGNORECASE  Perform case-insensitive matching.
        L  LOCALE      Make w, W, b, B, dependent on the current locale.
        M  MULTILINE   "^" matches the beginning of lines (after a newline)
                       as well as the string.
                       "$" matches the end of lines (before a newline) as well
                       as the end of the string.
        S  DOTALL      "." matches any character at all, including the newline.
        X  VERBOSE     Ignore whitespace and comments for nicer looking RE's.
        U  UNICODE     Make w, W, b, B, dependent on the Unicode locale.
</span>

<span style="font-size:18px;">>>> help (re.match)
这样查看每个方法的帮助文档, 可以看到每一种方法的参数
match(pattern, string, flags=0)
    Try to apply the pattern at the start of the string, returning
    a match object, or None if no match was found.
(END) </span>

<span style="font-size:18px;">>>> pattern = re.compile(r'hello') # 将正则表达式编译成Pattern对象
>>> match = pattern.match('hello world!') #使用Pattern匹配文本，获得匹配结果，无法匹配时将返回None
>>> if match:
...
print match.group()
#获得一个或多个分组截获的字符串；</span></span><span style="font-size:18px;">
...
hello</span>

re.compile(strPattern[, flag]):

这个方法是Pattern类的工厂方法，用于将字符串形式的正则表达式编译为Pattern对象。 第二个参数flag是匹配模式，取值可以使用按位或运算符'|'表示同时生效，比如re.I | re.M。另外，你也可以在regex字符串中指定模式，比如re.compile('pattern', re.I | re.M)与re.compile('(?im)pattern')是等价的。 
可选值有：

<span style="font-size:18px;">>>> m = re.match(r'hello','hello world')
>>> print m.group()
hello
</span>

<span style="font-size:18px;">>>> help(re.match)
Help on function match in module re:
match(pattern, string, flags=0)
Try to apply the pattern at the start of the string, returning
a match object, or None if no match was found.</span>

eg：

<span style="font-size:18px;">>>> print re.match(r'hello','hello world').group()
hello
>>> print re.match(r'hello','Python hello world').group()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'</span>

Match对象是一次匹配的结果，包含了很多关于此次匹配的信息，可以使用Match提供的可读属性或方法来获取这些信息。

属性：

1. string: 匹配时使用的文本。
2. re: 匹配时使用的Pattern对象。
3. pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
4. endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
5. lastindex: 最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组，将为None。
6. lastgroup: 最后一个被捕获的分组的别名。如果这个分组没有别名或者没有被捕获的分组，将为None。

方法：

1. group([group1, …]): 
   获得一个或多个分组截获的字符串；指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名；编号0代表整个匹配的子串；不填写参数时，返回group(0)；没有截获字符串的组返回None；截获了多次的组返回最后一次截获的子串。
2. groups([default]): 
   以元组形式返回全部分组截获的字符串。相当于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代，默认为None。
3. groupdict([default]): 
   返回以有别名的组的别名为键、以该组截获的子串为值的字典，没有别名的组不包含在内。default含义同上。
4. start([group]): 
   返回指定的组截获的子串在string中的起始索引（子串第一个字符的索引）。group默认值为0。
5. end([group]): 
   返回指定的组截获的子串在string中的结束索引（子串最后一个字符的索引+1）。group默认值为0。
6. span([group]): 
   返回(start(group), end(group))。
7. expand(template): 
   将匹配到的分组代入template中然后返回。template中可以使用id或g<id>、g<name>引用分组，但不能使用编号0。id与g<id>是等价的；但10将被认为是第10个分组，如果你想表达1之后是字符'0'，只能使用g<1>0。

<span style="font-size:18px;">>>> m = re.match(r'python','python hello')
>>> print m.group()
#获取分组截获的字符串
python
>>> print m.string
#获取匹配时使用的文本
python hello
>>> print m.re
#匹配时使用的Pattern对象(先将正则表达式的字符串形式编译为Pattern实例，
然后使用Pattern实例处理文本并获得匹配结果）
<_sre.SRE_Pattern object at 0xb7458bd0>
>>> print m.pos
#文本中正则表达式开始搜索的索引</span>
0
>>> print m.endpos
#文本中正则表达式结束搜索的索引，与len(string)相同</span>
12
>>> print m.lastindex
#最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组，将为None</span>
None
>>> print m.lastgroup
#最后一个被捕获的分组的别名。如果这个分组没有别名或者没有被捕获的分组，将
为None
None
>>> print m.groups()
以元组形式返回全部分组截获的字符串</span>
()
>>> print m.groupdict()
{}
>>> print m.start()
0
>>> print m.end()
6
>>> print m.span()
(0, 6)</span>

Pattern对象是一个编译好的正则表达式，通过Pattern提供的一系列方法可以对文本进行匹配查找。

Pattern不能直接实例化，必须使用re.compile()进行构造。

Pattern提供了几个可读属性用于获取表达式的相关信息：

1. pattern: 编译时用的表达式字符串。
2. flags: 编译时用的匹配模式。数字形式。
3. groups: 表达式中分组的数量。
4. groupindex: 以表达式中有别名的组的别名为键、以该组对应的编号为值的字典，没有别名的组不包含在内。

match VS search： re.match 从字符串的开始处开始匹配，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search 查找整个字符串，直到找到一个匹配；若无匹配返回None。

<span style="font-size:18px;">>>> print re.match(r'hello','hello world').group()
hello
>>> print re.match(r'hello','python hello world').group()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
>>> print re.search(r'hello','python hello world').group()
hello
</span>

<span style="font-size:18px;">>>> p = re.compile(r'(w+) (w+)')
#‘(w+) (w+)’空格连接的两个单词
>>> s = 'i say, hello world!'
>>> print p.sub(r'2 1', s)
#以id引用分组，将每个匹配中的两个单词掉转位置 
say i, world hello!
>>> def func(m):
#将匹配单词的首字母改为大写
...
return m.group(1).title() + ' ' + m.group(2).title()
...
>>> print p.sub(func, s)
I Say, Hello World!</span>

subn(pattern, repl, string, count=0, flags=0)：此函数的参数与 sub 函数完全一致，只不过其返回值是包括两个元素的元组：（new_string, number）；第一个返回值 new_string 为sub 函数的结果，第二个 number 为匹配及替换的次数。

<span style="font-size:18px;">>>> import re
>>> p = re.compile(r'(w+) (w+)')
>>> s = 'i say, hello world!'
>>> print p.subn(r'2 1', s)
('say i, world hello!', 2)
>>> def func(m):
...
return m.group(1).title() + ' ' + m.group(2).title()
...
>>> print p.subn(func, s)
('I Say, Hello World!', 2)</span>

4）、findall 

<span style="font-size:18px;">>>> p = re.compile(r'bwb')
>>> print p.findall('one 1 two 2 three 3 four 4')
['1', '2', '3', '4']
>>> p = re.compile(r'bw+b')
>>> print p.findall('one 1 two 2 three 3 four 4')
['one', '1', 'two', '2', 'three', '3', 'four', '4']</span>

5）、finditer

finditer(pattern, string, flags=0)：找到 RE 匹配的所有子串，并把它们作为一个迭代器返回。这个匹配是从左到右有序地返回。如果无匹配，返回空列表。

<span style="font-size:18px;">>>> p = re.compile(r'bw+b')
>>> for m in p.finditer('one1 two2 three3 four4'):
...
print m.group()
...
one1
two2
three3
four4</span>

6）、purge

purge():清空缓存中的正则表达式。

<span style="font-size:18px;">>>> p = re.compile(r'bw+b')
>>> p.search('one1 two2 three3 four4').group()
'one1'
>>> p = re.purge()
#清空缓存中的正则表达式
>>> p.search('one1 two2 three3 four4').group()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'search'
</span>

7)、split 

照旧，我们使用help:

<span style="font-size:18px;">>>> p = re.compile(r' ')
>>> print p.split('one1 two2 three3 four4')
['one1', 'two2', 'three3', 'four4']
</span>