python初步学习-Python模块之 re
re 正则表达式
python re正则表达式语法
- 匹配字符
| 语法 | 解释 | 表达式 | 匹配实例 |
|---|---|---|---|
| . | 匹配任意除“\n”以外的任何字符 | a.c | abc |
| \ | 转义符，改变原来符号含义 如果字符串中有字符 * 需要匹配，可以使用 \* 或者字符集[*] |
a.c a\c |
abe ace ade |
| [] | 字符集。对应的位置可以是字符集中任意字符。 字符集中的字符可以逐个列出，也可以给出范围，如[abc]或[a-c]。第一个字符如果是则表示取反，如[abc]表示不是abc的其他字符 |
a[bcd]e | abc ace ade |
- 预定义字符集(可以写在字符集[...]中)
| 语法 | 解释 | 表达式 | 匹配实例 |
|---|---|---|---|
| \d | 数字：[0-9] | a\dc | a1c a9c |
| \D | 非数字: [^\d] [^0-9] |
a\Dc | abc azc |
| \s | 空白字符：[<空格>\t\r\n\f\v] | a\sc | a c a\tc a\nc |
| \S | 非空白字符：[^\s] | a\Sc | abc a1c |
| \w | 单词字符：[A-Za-z0-9] | a\wc | abc |
| \W | 非单词字符：[^\w] | a\Wc | a c |
- 数量词(用在字符或(...)之后)
| 语法 | 解释 | 表达式 | 匹配实例 |
|---|---|---|---|
| * | 匹配前一个字符0或无限次 | abc* | ab abccc |
| + | 匹配前一个字符1次或无限次 | abc+ | abc abccc |
| ? | 匹配前一个字符0次或1次 | abc? | ab abc |
| {m} | 匹配前一个字符m次 | ab{2}c | abbc |
| {m,n} | 匹配前一个字符m至n次 m和n可以省略：若省略m，则匹配0至n次 若省略n,则匹配m至无限次 |
ab{1,2}c | abc abbc |
| ? +? ??* {m,n}? |
使 * + ？ {m,n}变成非贪婪模式 |
- 边界匹配(不消耗待匹配字符串中的字符)
| 语法 | 解释 | 表达式 |
|---|---|---|
| ^ | 匹配字符串开头 在多行模式中匹配每一行的开头 |
^abc |
| $ | 匹配字符串末尾 在多行模式中匹配每一行的末尾 |
abc$ |
| \A | 仅匹配字符串开头 | \Aabc |
| \Z | 仅匹配字符串末尾 | abc\Z |
| \b | 匹配\w和\W之间 | a\b!bc |
| \B | [^\b] | a\Bbc |
- 逻辑、分组
| 语法 | 解释 | 表达式 | 匹配实例 |
|---|---|---|---|
| | | |代表左右表达式任意匹配一个 它总是先尝试匹配左边的表达式，一旦成功匹配则跳过匹配走遍的表达式 如果|表达式没有被包含在()中，则它的范围是整个正则表达式 |
abc|def | abc def |
| (...) | 被阔气来的表达式将作为分组，从表达式左边开始没遇到一个分组的左括号"(",编号+1. 另外，分组表达式作为一个整体，可以后接数量词。 表达式中的|仅在该组中有效。 |
(abc){2} a(123 |
456) |
| (?P |
分组，除了原有的编号外在指定一个额外的字符串 | (?P |
abcabc |
| <number> | 引用编号为 |
(\d)abc\1 | 1abc1 5abc5 |
| (?P=name) | 引用别名为 |
(?P |
1abc1 5abc5 |
+++ 数量词的贪婪模式和非贪婪模式
正则表达式通常用于文本中查找匹配的字符串。Python 里数量词默认是贪婪的(在少数语言里也可能是默认非贪婪)，总是尝试匹配尽可能多的字符；非贪婪的则相反，总是尝试匹配尽可能少的字符。例如：正则表达式"ab*"如果用于查找“abbbc”，将找到“abbb”。而如果使用非贪婪的数量词"ab*?",将找到"a".
re 模块
- re.complie([pattern[,flags]])
把一个正则表达式 pattern 编译成正则对象，以便可以用正则对象的 match和search 方法。第二个参数flag是匹配模式，取值可以使用按位或运算符'|'表示同时生效，比如re.I | re.M。另外，你也可以在regex字符串中指定模式，比如re.compile('pattern', re.I | re.M)与re.compile('(?im)pattern')是等价的。
可选值有：
- re.I(re.IGNORECASE): 忽略大小写（括号内是完整写法，下同）
- M(MULTILINE): 多行模式，改变'^'和'$'的行为（参见上图）
- S(DOTALL): 点任意匹配模式，改变'.'的行为
- L(LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
- U(UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性
- X(VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。以下两个正则表达式是等价的：
a = re.compile(r"""\d + # the integral part
\. # the decimal point
\d * # some fractional digits""", re.X)
b = re.compile(r"\d+\.\d*")
表达式前面之所以有一个 r ，是表示 后面为原字符，如一些特殊符号需要转义比较麻烦，前面加一个 r，就可以一劳永逸了。
一下两段内容在语法上是等效的：
prog = re.compile(pattern)
result = prog.match(string)
result = re.match(pattern, string)
区别是，用了 re.compile 以后，正则对象会得到保留，这样在需要多次运用这个正则对象的时候，效率会有较大的提升。如下面的例子:
In [1]: import timeit
In [2]: timeit.timeit(
...: ... setup='''import re; reg = re.compile('<(?P<tagnam
...: e>\w*)>.*</(?P=tagname)>')''',
...: ... stmt='''reg.match('<h1>xxx</h1>')''',
...: ... number=1000000)
Out[2]: 0.5159049034118652
In [3]: timeit.timeit(
...: ... setup='''import re''',
...: ... stmt='''re.match('<(?P<tagname>\w*)>.*</(?P=tagna
...: me)>', '<h1>xxx</h1>')''',
...: ... number=1000000)
Out[3]: 1.5837020874023438
可以看到速度提升了3倍。
- match()
格式：re.match(pattern,string,flags=0)
如果匹配成功将返回一个 match() 对象，否则返回 None；
match()对象是一次匹配的结果，包含了很多关于此次匹配的信息，可以使用 match() 提供的可读属性或方法来获取这些信息。
In [30]: s1 = "hello world"
In [31]: p = re.compile(r"(he)")
In [32]: result = re.match(p,s1)
In [33]: print result
<_sre.SRE_Match object at 0x7f6a8c48bf30>
In [35]: print result.string
hello world
In [37]: print result.group()
he
- search()
格式：re.search(pattern,string,flags=0)
re.search()函数会在字符串内查找模式匹配，只要找到第一个匹配然后返回，如果字符串没有匹配，则返回 None
print(re.search('\dcom','www.4comrunoob.5com').group())
执行结果如下：
4com
注：match和search一旦匹配成功，就是一个match object对象，而match object对象有以下方法：
- group() 返回被 RE 匹配的字符串
- start() 返回匹配开始的位置
- end() 返回匹配结束的位置
- span() 返回一个元组包含匹配 (开始,结束) 的位置
- group() 返回re整体匹配的字符串，可以一次输入多个组号，对应组号匹配的字符串。
- a.group() 返回 re 整体匹配的字符串
- b.group(n,m)返回组号为n,m所匹配的字符串，如果组号不存在，则返回indexError异常
- c.groups() groups()方法返回一个包含正则表达式中所有小组字符串的元组，从1到所含的小组号，通常groups()不需要参数，返回一个元组，元组中的元就是正则表达式中定义的组
import re
a = "123abc456"
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(0)) #123abc456,返回整体
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1)) #123
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(2)) #abc
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(3)) #456
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).group(1,2)) #('123', 'abc')
print(re.search("([0-9]*)([a-z]*)([0-9]*)",a).groups()) #('123', 'abc', '456')
需要注意一点的是，search()的效率要比match()的效率低。因为 search() 会对整个字符串进行扫描，而 match() 只会从头开始匹配，如果开头匹配失败，则 return None。所以 search() 匹配需要花费的时间很多。推荐使用 match().
findall()
re.findall()遍历匹配，可以获得字符串中所有匹配的字符串，返回一个列表。
格式：
re.findall(pattern,string,flags=0)
p = re.compile(r"\d+")
print p.findall("one1two2three3four4")
执行结果如下：
['1', '2', '3', '4']
import re
tt = "Tina is a good girl, she is cool, clever, and so on..."
rr = re.compile(r'\w*oo\w*')
print re.findall(rr,tt)
['good', 'cool']
print re.findall(r'(\w)*oo(\w)',tt)
[('g', 'd'), ('c', 'l')]
finditer()
搜索string，返回一个顺序访问每一个匹配结果(match对象)的迭代器，找到 re 匹配的所有字符串，并把它们作为一个迭代器返回
格式：
re.finditer(pattern, string, flags=0)
iter = re.finditer(r'\d+','12 drumm44ers drumming, 11 ... 10 ...')
for i in iter:
print(i)
print(i.group())
print(i.span())
执行结果如下：
<_sre.SRE_Match object; span=(0, 2), match='12'>
12
(0, 2)
<_sre.SRE_Match object; span=(8, 10), match='44'>
44
(8, 10)
<_sre.SRE_Match object; span=(24, 26), match='11'>
11
(24, 26)
<_sre.SRE_Match object; span=(31, 33), match='10'>
10
(31, 33)
split()
能够按照匹配的字符串将 string 分割后返回列表
格式：
re.split(pattern,string[,maxsplit])
maxsplit 用于指定最大分割次数，不指定将全部分割
print re.spilt(r'\d+','one1two2three3four4five5')
执行结果如下:
['one', 'two', 'three', 'four', 'five', '']
