python re sub dict_python re

1. re的简介

使用python的re模块，尽管不能满足所有复杂的匹配情况，但足够在绝大多数情况下能够有效地实现对复杂字符串的分析并提取出相关信息。python 会将正则表达式转化为字节码，利用 C 语言的匹配引擎进行深度优先的匹配。

复制代码 代码如下:

import re

print re.__doc__

可以查询re模块的功能信息，下面会结合几个例子说明。

2. re的正则表达式语法

正则表达式语法表如下：

语法

意义

说明

"."

任意字符

"^"

字符串开始

'^hello'匹配'helloworld'而不匹配'aaaahellobbb'

"$"

字符串结尾

与上同理

"*"

0 个或多个字符(贪婪匹配)

匹配

chinaunix

"+"

1 个或多个字符(贪婪匹配)

与上同理

"?"

0 个或多个字符(贪婪匹配)

与上同理

*?,+?,??

以上三个取第一个匹配结果(非贪婪匹配)

匹配

{m,n}

对于前一个字符重复m到n次，{m}亦可

a{6}匹配6个a、a{2,4}匹配2到4个a

{m,n}?

对于前一个字符重复m到n次，并取尽可能少

‘aaaaaa'中a{2,4}只会匹配2个

"\\"

特殊字符转义或者特殊序列

[]

表示一个字符集

[0-9]、[a-z]、[A-Z]、[^0]

"|"

或

A|B,或运算

(...)

匹配括号中任意表达式

(?#...)

注释，可忽略

(?=...)

Matches if ... matches next, but doesn't consume the string.

'(?=test)'  在hellotest中匹配hello

(?!...)

Matches if ... doesn't match next.

'(?!=test)'若hello后面不为test，匹配hello

(?<=...)

Matches if preceded by ... (must be fixed length).

'(?<=hello)test'  在hellotest中匹配test

(?

Matches if not preceded by ... (must be fixed length).

'(?

正则表达式特殊序列表如下：

特殊序列符号

意义

\A

只在字符串开始进行匹配

\Z

只在字符串结尾进行匹配

\b

匹配位于开始或结尾的空字符串

\B

匹配不位于开始或结尾的空字符串

\d

相当于[0-9]

\D

相当于[^0-9]

\s

匹配任意空白字符:[\t\n\r\r\v]

\S

匹配任意非空白字符:[^\t\n\r\r\v]

\w

匹配任意数字和字母:[a-zA-Z0-9]

\W

匹配任意非数字和字母:[^a-zA-Z0-9]

3. re的主要功能函数

常用的功能函数包括：compile、search、match、split、findall(finditer)、sub(subn)

1). compile

re.compile(pattern[, flags])

作用：把正则表达式语法转化成正则表达式对象

flags定义包括：

re.I：忽略大小写

re.L：表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境

re.M：多行模式

re.S：' . '并且包括换行符在内的任意字符(注意：' . '不包括换行符)

re.U： 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库

2). search

re.search(pattern, string[, flags])

search (string[, pos[, endpos]])

作用：在字符串中查找匹配正则表达式模式的位置，返回 MatchObject 的实例，如果没有找到匹配的位置，则返回 None。

1 #r2 = re.compile(r'n$', re.S)

2 #r2 = re.compile('\n$', re.S)

3 r2 = re.compile('World$', re.I)4 if r2.search('helloworld\n'):5 print 'search succeeds'

6 else:7 print 'search fails'

1 #例：直接调用

2

3 if re.search(r'abc','helloaaabcdworldn'):4 print 'search succeeds'

5 else:6 print 'search fails'

7

8 split9 re.split(pattern, string[, maxsplit=0, flags=0])10 split(string[, maxsplit=0])11 #作用：可以将字符串匹配正则表达式的部分割开并返回一个列表

3). match

re.match(pattern, string[, flags])

match(string[, pos[, endpos]])

作用：match() 函数只在字符串的开始位置尝试匹配正则表达式，也就是只报告从位置 0 开始的匹配情况，而 search() 函数是扫描整个字符串来查找匹配。如果想要搜索整个字符串来寻找匹配，应当用 search()。

1 #!/usr/bin/env python

2 importre3 r1 = re.compile(r'world')4 if r1.match('helloworld'):5 print 'match succeeds'

6 else:7 print 'match fails'

8 if r1.search('helloworld'):9 print 'search succeeds'

10 else:11 print 'search fails'

4). split

1 #例：简单分析ip

2

3 #!/usr/bin/env python

4 importre5 r1 = re.compile('W+')6 print r1.split('192.168.1.1')7 print re.split('(W+)', '192.168.1.1')8 print re.split('(W+)', '192.168.1.1', 1)9

10

11 结果如下：12 ['192', '168', '1', '1']13 ['192', '.', '168', '.', '1', '.', '1'] ------>注意 () 的使用14 ['192', '.', '168.1.1']

5). findall

re.findall(pattern, string[, flags])

findall(string[, pos[, endpos]])

作用：在字符串中找到正则表达式所匹配的所有子串，并组成一个列表返回

1 >>> print re.findall('\[.*\]', "hello[hi]heldfsdsf[iwonder]lo")2 ['[hi]heldfsdsf[iwonder]']

6). finditer

re.finditer(pattern, string[, flags])

finditer(string[, pos[, endpos]])

说明：和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并组成一个迭代器返回。

7). sub

re.sub(pattern, repl, string[, count, flags])

sub(repl, string[, count=0])

说明：在字符串 string 中找到匹配正则表达式 pattern 的所有子串，用另一个字符串 repl 进行替换。如果没有找到匹配 pattern 的串，则返回未被修改的 string。Repl 既可以是字符串也可以是一个函数。

8). subn

re.subn(pattern, repl, string[, count, flags])

subn(repl, string[, count=0])

1 >>> print p.sub('num', 'one word two words three words apple', 1)2 num word two words three words apple3 >>>

4 >>>

5 >>> print p.subn('num', 'one word two words three words apple')6 ('num word num words num words apple', 3)7 >>>

9). nescape

对字符串中的非字母数字进行转义

1 matches = re.findall(re.escape('-----------------------ASP') + r'.*?'+ re.escape('radius-server-name'), recv_buff, re.S)

1 >>> print re.escape('abc123_@#$')2 abc123\_\@\#\$

10). purge

清空缓存中的正则表达式

有待验证！

4. 正则对象

正则对象由re.compile()返回。它有如下的属性和方法。

match(string[, pos[, endpos]])作用和模块的match()函数类似，区别就是后面两个参数。

pos是开始搜索的位置，默认为0。endpos是搜索的结束位置，如果endpos比pos还小的话，结果肯定是空的。也就是说只有pos 到 endpos-1 位置的字符串将会被搜索。

例子：

1 >>> pattern = re.compile("o")2 >>> pattern.match("dog") #开始位置不是o，所以不匹配

3 >>> pattern.match("dog", 1) #第二个字符是o，所以匹配

4 <_sre.sre_match object at ...>

5 search(string[, pos[, endpos]])

search(string[, pos[, endpos]])

作用和模块的search()函数类似，pos和endpos参数和上面的match()函数类似。

split(string[, maxsplit=0])

findall(string[, pos[, endpos]])

finditer(string[, pos[, endpos]])

sub(repl, string[, count=0])

subn(repl, string[, count=0])

这几个函数，都和模块的相应函数一致。

flags编译本RE时，指定的标志位，如果未指定任何标志位，则为0。

>>> pattern = re.compile("o", re.S|re.U)>>>pattern.flags48

groupsRE所含有的组的个数。

groupindex一个字典，定义了命名组的名字和序号之间的关系。

例子：这个正则有3个组，如果匹配到，第一个叫区号，最后一个叫分机号，中间的那个未命名

>>> pattern = re.compile("(?P\d+)-(\d+)-(?P\d+)")>>>pattern.groups3

>>>pattern.groupindex

{'fenjihao': 3, 'quhao': 1}

pattern建立本RE的原始字符串，相当于源代码了，呵呵。

还是上面这个正则，可以看到，会原样返回：

>>> printpattern.pattern

(?P\d+)-(\d+)-(?P\d+)

Match对象

re.MatchObject被用于布尔判断的时候，始终返回True，所以你用 if 语句来判断某个 match() 是否成功是安全的。

它有以下方法和属性：

expand(template)用template做为模板，将MatchObject展开，就像sub()里的行为一样，看例子：

1 >>> m = re.match('a=(\d+)', 'a=100')2 >>> m.expand('above a is \g<1>')3 'above a is 100'

4 >>> m.expand(r'above a is \1')5 'above a is 100'

貌似很牛逼的样子！！！！

group([group1, ...])

返

回一个或多个子组。如果参数为一个，就返回一个子串；如果参数有多个，就返回多个子串注册的元组。如果不传任何参数，效果和传入一个0一样，将返回整个匹

配。如果某个groupN未匹配到，相应位置会返回None。如果某个groupN是负数或者大于group的总数，则会抛出IndexError异常。

>>> m = re.match(r"(\w+) (\w+)", "Isaac Newton, physicist")>>> m.group(0) #整个匹配

'Isaac Newton'

>>> m.group(1) #第一个子串

'Isaac'

>>> m.group(2) #第二个子串

'Newton'

>>> m.group(1, 2) #多个子串组成的元组

('Isaac', 'Newton')

如果有其中有用(?P...)这种语法命名过的子串的话，相应的groupN也可以是名字字符串。例如：

>>> m = re.match(r"(?P\w+) (?P\w+)", "Malcolm Reynolds")>>> m.group('first_name')'Malcolm'

>>> m.group('last_name')'Reynolds'

如果某个组被匹配到多次，那么只有最后一次的数据，可以被提取到：

>>> m = re.match(r"(..)+", "a1b2c3") #匹配到3次

>>> m.group(1) #返回的是最后一次

'c3'

groups([default])返回一个由所有匹配到的子串组成的元组。default参数，用于给那些没有匹配到的组做默认值，它的默认值是None

例如：

>>> m = re.match(r"(\d+)\.(\d+)", "24.1632")>>>m.groups()

('24', '1632')#default的作用：

>>> m = re.match(r"(\d+)\.?(\d+)?", "24")>>> m.groups() #第二个默认是None

('24', None)>>> m.groups('0') #现在默认是0了

('24', '0')

groupdict([default])返回一个包含所有命名组的名字和子串的字典，default参数，用于给那些没有匹配到的组做默认值，它的默认值是None，例如：

>>> m = re.match(r"(?P\w+) (?P\w+)", "Malcolm Reynolds")>>>m.groupdict()

{'first_name': 'Malcolm', 'last_name': 'Reynolds'}

start([group])

end([group])

返回的是：被组group匹配到的子串在原字符串中的位置。如果不指定group或group指定为0，则代表整个匹配。如果group未匹配到，则返回 -1。

对于指定的m和g，m.group(g)和m.string[m.start(g):m.end(g)]等效。

注意：如果group匹配到空字符串，m.start(group)和m.end(group)将相等。

例如：

>>> m = re.search('b(c?)', 'cba')>>>m.start(0)1

>>>m.end(0)2

>>> m.start(1)2

>>> m.end(1)2

下面是一个把email地址里的“remove_this”去掉的例子：

>>> email = "tony@tiremove_thisger.net"

>>> m = re.search("remove_this", email)

>>> email[:m.start()] + email[m.end():]

'tony@tiger.net'

span([group])返回一个元组： (m.start(group), m.end(group))

pos就是传给RE对象的search()或match()方法的参数pos，代表RE开始搜索字符串的位置。

endpos就是传给RE对象的search()或match()方法的参数endpos，代表RE搜索字符串的结束位置。

lastindex最后一次匹配到的组的数字序号，如果没有匹配到，将得到None。

例如：(a)b、((a)(b))和((ab))正则去匹配'ab'的话，得到的lastindex为1。而用(a)(b)去匹配'ab'的话，得到的lastindex为2。

lastgroup最后一次匹配到的组的名字，如果没有匹配到或者最后的组没有名字，将得到None。

re得到本Match对象的正则表达式对象，也就是执行search()或match()的对象。

string传给search()或match()的字符串。

后面的例子就略了吧，文中已经加了很多我自己的例子了，需要更多例子的话，参照英文原文吧(https://docs.python.org/2/library/re.html)。