python 正则表达式Re

Python正则表达式指南这篇文章很好，推荐阅读。

本文则是简单记录下我自己学习Re的笔记， 环境是python3.5。

### 1.简单的Re语法
* `^` 匹配字符串开始位置。
* `$` 匹配字符串结束位置。
* `\b` 匹配一个单词边界。
* `\d` 匹配一个数字。
* `\D` 匹配一个任意的非数字字符。
* `x?` 匹配可选的 x 字符。换句话说，就是 0 个或者 1 个 x 字符。但是?还有第二个含义，作为正则的懒惰模式。
* `x*` 匹配 0 个或更多的 x。
* `x+` 匹配 1 个或者更多 x。
* `x{n,m}` 匹配 n 到 m 个 x，至少 n 个，不能超过 m 个。
* `x{n}`匹配n个x，一定是n个
* `(a|b|c)` 匹配单独的任意一个 a 或者 b 或者 c。
* `(x)` 这是一个组，它会记忆它匹配到的字符串。
* `\w` 一个字母或数字
* `.` 任意字符
* `\s` 空格
* `[]` 表示范围，[0-9a-zA-Z\_]可以匹配一个数字、字母或者下划线。
* `[^]` 作为方括号中的第一个字符， `^`有特别的含义：非。 `[^abc]` 的意思是： “ 除了 a、 b 或 c之外的任何字符”。
```
>>> re.search('[^aeiou]y$', 'vacancy')

>>> re.search('[^aeiou]y$', 'boy')
>>>
```

2.自然字符串

如果你想要指示某些不需要如转义符那样的特别处理的字符串，那么你需要指定一个自然字符串。自然字符串通过给字符串加上前缀r或R来指定。例如r"Newlines are indicatedby \n"。

一定要用自然字符串处理正则表达式。否则会需要使用很多的反斜杠。例如，后向引用符可以写成'\1'或r'\1'。

强烈建议使用 Python 的 r 前缀，就不用考虑转义的问题了。

### 3.re.search(pattern, string, flags=0) 和 re.match(pattern, string, flags=0)
`search()`的帮助信息：`Scan through string looking for a match to the pattern, returning a match object, or None if no match was found.`。`match()`的帮助信息：`Try to apply the pattern at the start of the string, returning a match object, or None if no match was found.`。

re 模块最基本的方法是 search()函数（类似于match()函数）。它使用正则表达式来匹配字符串（ M）。如果成功匹配， search()返回一个匹配对象。

>>> pattern = '^M?M?M?$'
>>> re.search(pattern, 'M')
<_sre.SRE_Match object; span=(0, 1), match='M'>

match()函数同样的功能。

>>> pattern = '^M?M?M?$'
>>> re.match(pattern, 'M')
<_sre.SRE_Match object; span=(0, 1), match='M'>

re.match()只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search()匹配整个字符串，直到找到一个匹配。

#!/usr/bin/python
import re
line = "Cats are smarter than dogs";

matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print("match --> matchObj.group() : ", matchObj.group())
else:
   print("No match!!")

matchObj = re.search( r'dogs', line, re.M|re.I)
if matchObj:
   print("search --> matchObj.group() : ", matchObj.group())
else:
   print("No match!!")

# No match!!
# search --> matchObj.group() :  dogs
# [Finished in 0.1s]

### 4.re.compile(pattern, flags=0)
`Compile a regular expression pattern, returning a pattern object.`
Re模块的`compile()`方法编译正则表达式，返回一个pattern对象。
编译后生成的 pattern 对象，已经包含了正则表达式(regular expression)，所以调用对应的方法时不用给出正则表达式了。
用编译后的pattern对象去匹配字符串`patternobj.search(string)`，如果匹配成功，返回的结果调用`groups()`方法，可以得到这个正则表达式中定义的所有分组结果组成的元组。
但如果`search()`方法匹配不成功，返回`None`，它没有 `groups()`方法，所以调用 None.groups()将会抛出一个异常。
```
>>> phonePattern = re.compile(r'^(\d{3})-(\d{3})-(\d{4})$')

dir(phonePattern)

['class', 'copy', 'deepcopy', 'delattr', 'dir', 'doc', 'eq', 'format', 'ge', 'getattribute', 'gt', 'hash', 'init', 'le', 'lt', 'ne', 'new', 'reduce', 'reduce_ex', 'repr', 'setattr', 'sizeof', 'str', 'subclasshook', 'findall', 'finditer', 'flags', 'fullmatch', 'groupindex', 'groups', 'match', 'pattern', 'scanner', 'search', 'split', 'sub', 'subn']

phonePattern

re.compile('^(\d{3})-(\d{3})-(\d{4})$')

m = phonePattern.search('800-555-1212')

m

<_sre.SRE_Match object; span=(0, 12), match='800-555-1212'>

m.groups()

('800', '555', '1212')

匹配失败

phonePattern.search('800-555-1212-1234').groups()

Traceback (most recent call last):

File "<pyshell#24>", line 1, in

phonePattern.search('800-555-1212-1234').groups()

AttributeError: 'NoneType' object has no attribute 'groups'

<br/>
### 5. re.sub(pattern, repl, string, count=0, flags=0)

Return the string obtained by replacing the leftmost
non-overlapping occurrences of the pattern in string by the
replacement repl.  repl can be either a string or a callable;
if a string, backslash escapes in it are processed.  If it is
a callable, it's passed the match object and must return
a replacement string to be used.

正则表达式模块的`re.sub()`函数可以做字符串替换，如下它在字符串 s 中用正则表达式‘ROAD$’来搜索并替换成‘RD.’。

s = '100 NORTH BROAD ROAD'

import re

re.sub('ROAD$', 'RD.', s)

'100 NORTH BROAD RD.'

re.sub('[abc]', 'o', 'caps')

'oops'

可能会认为该函数会将 caps 转换为 oaps，但实际上并不是这样。`re.sub()` 替换所有的匹配项，而不仅仅是第一个匹配项。因此该正则表达式将 caps 转换为 oops，因为无论是 c 还是 a 均被转换为 o 。
在替换字符串中，用到了新的语法： \1，它表示“嘿，记住的第一个分组呢？把它放到这里。 ”在此例中， 记住了 y 之前的 c ，在进行替换时，将用 c 替代 c，用 ies 替代 y 。（如果有超过一个的记忆分组，可以使用 \2 和 \3 等等。）

re.sub('([^aeiou])y$', r'\1ies', 'vacancy')

'vacancies'

<br/>
### 6. re.findall(pattern, string, flags=0)

Return a list of all non-overlapping matches in the string.

If one or more capturing groups are present in the pattern, return
a list of groups; this will be a list of tuples if the pattern
has more than one group.

Empty matches are included in the result.

`re.findall()`接受一个正则表达式和一个字符串作为参数，然后找出字符串中出现该模式的所有地方。在这个例子里，模式匹配的是数字序列。`findall()`函数返回所有匹配该模式的子字符串的列表。

re.findall('[0-9]+', '16 2-by-4s in rows of 8')

['16', '2', '4', '8']

这里正则表达式匹配的是字母序列。再一次，返回值是一个列表，其中的每一个元素是匹配该正则表达式的字符串。

re.findall('[A-Z]+', 'SEND + MORE == MONEY')

['SEND', 'MORE', 'MONEY']

**懒惰模式和贪婪模式**
`.*`具有贪婪的性质，首先匹配到不能匹配为止，根据后面的正则表达式，会进行回溯。
`.*？`则相反，一个匹配以后，就往下进行，所以不会进行回溯，具有最小匹配的性质。
`?`的一个用法是匹配0次或1次。但是`?`还有第二个含义，作为正则的懒惰模式。后边多一个`?`表示懒惰模式，必须跟在`*`或者`+`后边用。
re 正则有两种模式，一种为贪婪模式（默认），另外一种为懒惰模式，以下为例：
`(abc)dfe(gh)`
对上面这个字符串使用`(.*)`将会匹配整个字符串，因为正则默认是尽可能多的匹配。
虽然`(abc)`满足我们的表达式，但是`(abc)dfe(gh)`也同样满足，所以正则会匹配多的那个。
如果我们只想匹配`(abc)`和`(gh)`就需要用到以下的表达式`(.*?)`

惰性模式匹配示例：

re.findall(' s.*? s', "The sixth sick sheikh's sixth sheep's sick.")

[' sixth s', " sheikh's s", " sheep's s"]

re.findall(' s.* s', "The sixth sick sheikh's sixth sheep's sick.")

[" sixth sick sheikh's sixth sheep's s"]

加上分组：

re.findall(' s(.*?) s', "The sixth sick sheikh's sixth sheep's sick.")

['ixth', "heikh's", "heep's"]