Python正则表达式常用函数详解：match()、search()、findall()和finditer()的区别与用法
今天学习了 Python 里有关正则表达式这方面的知识。对于正则表达式的语法，不做过多的解释，因为在网上有很多可供学习的资料。这里主要是对 Python 中常用的正则表达式处理函数进行介绍。
方法/属性
作用
match()
决定 RE 是否在字符串刚开始的位置匹配
search()
扫描字符串，找到这个 RE 匹配的位置
findall()
找到 RE 匹配的所有子串，并把它们作为一个列表返回
finditer()
找到 RE 匹配的所有子串，并把它们作为一个迭代器返回
match()函数会检查 RE 是否仅在字符串的起始位置进行匹配。search()函数则会对整个字符串进行扫描。
match() 只会报告一次成功的匹配，并且是从 0 处开始的。如果匹配不是从 0 开始的，那么 match() 就不会报告它。
search() 会对整个字符串进行扫描，然后报告它所找到的第一个匹配情况。
match()、seerch（）、finditer（）在匹配成功时会返回一个 Match Object 对象，这个对象具备以下这些属性和方法：
方法/属性
作用
group()
返回被 RE 匹配的字符串
start()
返回匹配开始的位置
end()
返回匹配结束的位置
span()
返回一个元组包含匹配 (开始,结束) 的位置
group()会返回 re 整体匹配的字符串。它可以一次接收多个组号，然后返回对应组号所匹配的字符串。
1. group（）返回re整体匹配的字符串，
group(n, m) 会返回组号为 n 和 m 所匹配的字符串。如果组号不存在，就会返回 indexError 异常。
#!python
p 是通过 re.compile 函数编译得到的，编译的内容是 'a(b)c)d' 这个字符串。
m 对 'abcd' 进行了匹配操作
>>> m.group(0)
'abcd'
>>> m.group(1)
'abc'
>>> m.group(2)
'b'
groups()方法会返回一个元组，这个元组包含正则表达式中的所有小组字符串。这些小组的编号从 1 开始，一直到正则表达式所含的小组号。通常情况下，groups()方法不需要参数，它会返回一个元组，元组中的元素就是正则表达式中定义的组。
#!python
>>> p = re.compile('(a(b)c)d')
>>> m = p.match('abcd')
>>> m.groups()
('abc', 'b')
使用索引取得相应的组内容，例如：m.groups()[0]
p2 等于使用 re.compile 函数来编译一个正则表达式模式，该模式是由字符串 '(\d)+\w' 组成，并且使用了 re.X 标志（用于扩展正则表达式的语法）
例如 '123a' 或 '12123c' 等这样的字符串
'123a'
p2 与 '123a b12123c' 进行匹配，然后获取匹配到的结果的组 0 部分
'123a'
p2.match('123a b12123c').group(1)，该操作会返回正则表达式中第一个小组（\d）所匹配的字符串
'3'
p2 与 '123a b12 123c' 进行匹配，然后获取匹配结果的分组。
('3',)
re.match 会从字符串的开头开始进行匹配，然后会返回一个 Match Object ，如果没有匹配成功则返回 None 。
re.match 会尝试从字符串的起始位置开始去匹配一个模式。例如：下面的这个例子是用来匹配第一个单词的。
import re 如果在文本 text 中进行匹配操作，使用 re.match 函数，会匹配到以一个或多个单词字符开头，后面跟一个空格的内容，将匹配到的结果赋值给变量 m 。 if m: 打印 m 组的 0 部分，换行，打印 m 组的 1 部分 else: print 'not match'
re.match 的函数原型包含 flags 这个参数。
第一个参数是正则表达式，这里的正则表达式为"(\w+)\s"。如果该正则表达式匹配成功，就会返回一个 Match；如果匹配不成功，就会返回一个 None。
第二个参数表示要匹配的字符串；
第三个参数是标致位，它的作用是控制正则表达式的匹配方式。比如：可以控制是否区分大小写，是否进行多行匹配等等。
方法/属性
作用
group()
返回被 RE 匹配的字符串
start()
返回匹配开始的位置
end()
返回匹配结束的位置
span()
返回一个元组包含匹配 (开始,结束) 的位置
re.search 会在字符串当中进行查找匹配操作，它能够找到第一个匹配的部分，然后返回一个 Match Object ，要是没有找到匹配的部分，就会返回 None 。
re.search 函数会在字符串内进行查找模式匹配的操作。它会一直查找直到找到第一个匹配的部分，接着就会返回。如果在字符串中没有找到匹配的内容，那么就会返回 None。
import re text = "JGood is a handsome boy, he is cool, clever, and so on..." 在 text 中进行搜索，使用 re.search 函数，搜索的模式是 '\shan(ds)ome\s'，将搜索结果赋值给变量 m if m: print m.group(0), m.group(1) else: print 'not search'
re.search 的函数原型是：re.search 具有 pattern、string 和 flags 这三个参数。re.search 用于在 string 中搜索匹配 pattern 的内容，同时可以通过 flags 来控制搜索的行为和特性。
每个参数的含意与re.match一样。
re.match 的特点是只对字符串的起始部分进行匹配，倘若字符串的起始部分与正则表达式不相符，那么匹配就会失败，此时函数会返回 None；re.search 的特点则是会对整个字符串进行匹配，一直到找到一个匹配为止。
re.sub 会将所有的匹配项进行替换，然后返回一个替换后的字符串。如果没有匹配成功，就会返回原来的字符串。
re.sub 可以用来替换字符串里的匹配项。下面有一个例子，它把字符串中的空格“ ”替换成了“-”。
import re text = "JGood is a handsome boy, he is cool, clever, and so on..." 使用 re.sub 函数，将字符串 text 中的连续空白字符（\s+）替换为“-”，然后打印替换后的结果。
re.sub 的函数原型是：re.sub 具有 pattern、repl、string、count 这些参数。re.sub 函数中的 pattern 是用于匹配的模式。re.sub 函数中的 repl 是替换的字符串。re.sub 函数中的 string 是要进行替换操作的字符串。re.sub 函数中的 count 是可选参数，表示替换的次数。
其中第二个函数所对应的是替换后的字符串；在本例当中，这个字符串为“-”
第四个参数指替换个数。默认为0，表示每个匹配项都替换。
re.sub 能够利用函数来对匹配项的替换进行复杂的处理。例如：re.sub(r'\s', lambda m: '[' + m.group(0) + ']', text, 0)；此操作会把字符串里的空格' '替换成'[ ]'。
sub()方法能提供一个替换值，这个替换值可以是字符串，也可以是一个函数，同时还有一个需要被处理的字符串。
使用模块级的 re.sub()函数时，模式处于第一个参数的位置。模式或许是一个字符串，也或许是一个 `RegexObject`；倘若你需要明确指定正则表达式标志，那么你就必须要么运用 `RegexObject` 作为第一个参数，要么采用模式内嵌修正器，例如 sub("(?i)b+", "x", "bbbb BBBB") 会返回 'x x'。
import re
def hexrepl( match ):
返回一个十进制数对应的十六进制字符串。
value = int( match.group() )
return hex(value)
使用 re 模块的 compile 函数创建了一个正则表达式模式，该模式是 '\d+' ，用于匹配一个或多个数字。
打印 p.sub(hexrepl, 'Call 65490 for printing, 49152 for user code.')
import re
text = "JGood is a handsome boy, he is cool, clever, and so on..."
使用 re.sub 函数，将字符串 text 中连续的空白字符（\s+）替换为单个连字符（-），然后打印替换后的结果。
JGood 是一个帅气的男孩，他很冷酷，很聪明，等等……
使用 re.sub 函数，将字符串中的空格替换为 lambda 函数返回的结果，即把空格替换为 [空格字符]，然后打印替换后的字符串。具体来说，就是在正则表达式 r'\s' 匹配到的空格处，执行 lambda 函数 m: '[' + m.group(0) + ']' 的操作，最后将替换后的字符串进行打印输出。
JGood 是一个帅气的男孩，他很酷炫，很聪明，等等……
使用 re.sub 函数，将 text 中的 'a' 替换为 lambda 函数返回的 '[a]'，即实现了在 'a' 的两边加 '[' 和 ']' 的效果。也可以使用 string.replace() 方法来进行类似的操作。
subn 与 sub 是相同的，但它会返回新的字符串以及替换的次数。
使用 re.subn 函数，将字符串 'Paris in the the spring' 中的 'i' 替换为 'I'，得到的结果是 ('ParIs In the the sprIng', 3)
空匹配只有在它们没有紧挨着前一个匹配时才会被替换掉。
#!python
p 被用于编译模式 'x*' 。
p 进行了一个操作，这个操作是用 '-' 去减 'abxd'
'-a-b-d-'
re.split 以列表形式返回分割的字符串
可以利用 re.split 来对字符串进行分割，例如：re.split(r'\s+', text)；这样就能把字符串按照空格分割成一个单词的列表。
将字符串进行拆分，拆分的次数可以指定，若不指定则默认拆分所有。可以通过指定最大拆分次数来控制拆分的程度。
你能够通过设定 maxsplit 的值来对分片数进行限制。当 maxsplit 不为零的时候，最多只会有 maxsplit 个分片，而字符串的其余部分会被当作列表的最后部分进行返回。在接下来的例子里，定界符可以是任意由非数字字母字符所组成的序列。
#!python
使用 re 模块的 compile 方法创建了一个正则表达式模式对象 p，该模式为 \W+ ，即匹配一个或多个非单词字符。
p 对 'This is a test, short and sweet, of split().' 进行拆解。
p 对 "This is a test, short and sweet, of split()." 进行分割操作，分割次数为 3 次。
有时，你不仅对定界符之间的文本感兴趣，还需要知晓定界符是什么。定界符可以是任意非数字字母字符的序列。如果在 RE 中使用捕获括号，那么它们（定界符）的值也会被当作列表的一部分返回。比较以下的调用：
re.split("([ab])", "carbs") ，这样就会得到结果 ['c', 'a', 'r', 'b', 's'] ，这里的定界符是 a 或者 b ，最终返回的是界定符 a 和 b 。
结果是 ['carbs']
#!python
>>> p = re.compile(r'\W+')
p2 是一个通过 re.compile 函数编译的正则表达式对象，它的模式是 (\W+) ，其中 (\W+) 表示匹配一个或多个非单词字符。
p 对 'This... is a test.' 进行分割操作。
p2 进行了对特定内容的分割操作，即对 'This... is a test.' 进行分割。
re.findall 以列表形式返回所有匹配的字符串
re.findall 能够获取字符串里所有匹配的字符串。例如：re.findall(r'\w*oo\w*', text)，这样就可以获取到字符串中包含“oo”的所有单词。
(pattern)匹配pattern并获取这一匹配
import re
使用 re.findall 函数来查找文本中包含“oo”的单词或字符串。在给定的示例中，查找结果为['JGood', 'cool']。
使用 re.findall 函数来查找符合正则表达式 r'(\w)*oo(\w)*' 的内容，在给定的 text 中进行搜索。结果为 [('G', 'd'), ('c', 'l')] ，其中 ('G', 'd') 和 ('c', 'l') 分别是找到的匹配项，每个匹配项由两个子表达式组成，第一个子表达式 (\w)* 匹配零个或多个字母字符，第二个子表达式 oo 匹配字符串 'oo' ，第三个子表达式 (\w)* 再次匹配零个或多个字母字符。
在 Python 2.2 里，能够使用 finditer()方法。
#!python iterator 等于 p 查找所有匹配项的迭代器，匹配的内容是 '12 drummers drumming, 11... 10...' >>> iterator>>> for match in iterator: 输出 match 所匹配的内容以及其所在的位置范围，即输出 match.group() 和 match.span() 。 ... 12 (0, 2) 11 (22, 24) 10 (29, 31)
re.compile
可以将正则表达式编译为一个正则表达式对象。对于那些经常被使用的正则表达式，可以将其编译成正则表达式对象，以此来提升一定的效率。以下是一个正则表达式对象的示例：
phper