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

@H_404_662@

<span style="font-size:18px;">>>> help(re.match)

Help on function match in module re:

match(pattern,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','python hello world').group()
Traceback (most recent call last):
  File "<stdin>",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,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'\b\w\b')
>>> print p.findall('one 1 two 2 three 3 four 4')
['1','2','3','4']
>>> p = re.compile(r'\b\w+\b')
>>> print p.findall('one 1 two 2 three 3 four 4')
['one','1','two','three','four','4']</span>

5）、finditer

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

<span style="font-size:18px;">>>> p = re.compile(r'\b\w+\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'\b\w+\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>",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>