核心笔记:查找与匹配的比较
15.1.1 您的第一个正则表达式:
15.2 正则表达式使用的特殊符号和字符
常用正则表达式符号和特殊符号:
记号 说明 举例
literal 匹配字符串的值 foo
re1|re2 匹配正则表达式re1或re2 foo|bar
. 匹配任何字符(换行符除外) b.b
^ 匹配字符串的开始 ^Dear
$ 匹配字符串的结尾 /bin/*sh$
* 匹配前面出现的正则表达式零次或多次 [A-Za-z0-9]*
+ 匹配前面出现的正则表达式一次或多次 [a-z]+\.com
? 匹配前面出现的正则表达式零次或一次 goo?
{N} 匹配前面出现的正则表达式N次 [0-9]{3}
{M,N} 匹配重复出现M次到N次的正则表达式 [0-9]{5,9}
[....] 匹配字符组里出现的任意一个字符 [aeiou]
[..x-y..] 匹配从字符x到y中的任意一个字符 [0-9],[A-Za-z]
[^...] 不匹配此字符集中出现的任何一个字符,[^aeiou],
包括某一范围的字符(如果在此字符集中出现) [^A-Za-z0-9_]
{*|+|?|{}}? 用于上面出现的任何"非贪婪"版本 .*?[a-z]
重复匹配次数符号
{...} 匹配封闭括号中正则表达式(RE),并保存为子组 {[0-9]{3}}?,f(00|u)bar
\d 匹配任何数字,和[0-9]一样(\D是\d的反义,
任何非数符字) data\d+.txt
\w 匹配任何数字字母字符,和[A-Za-z0-9_]相同
(\W是\w的反义) [A-Za-z_]\w+
\s 匹配任何空白符,和[\n\t\r\v\f]相同(\S同上)
of\sthe\b匹配单词边界(\B同上) \bThe\b
\nn 匹配已保存的子组 price: \16
\c 逐一匹配特殊字符 c(即,取消他的特殊含义,
按字面匹配) \., \\, \*
\A {\Z} 匹配字符串的起始(结束) \ADear
15.2.1 用管道符号(|)匹配多个正则表达式模式
表示选择被管道符号分割的多个不同的正则表达式中的一个
正则表达式模式匹配的字符串
at|homeat,home
r2d2|c3por2d2,c3po
bat|bet|bitbat,bet,bit
管道符是的它可以匹配多个字符串
15.2.2 匹配任意一个单个字符(.)
正则表达式匹配的字符串
f.o在f和o中间的任意字符,如fao,f0o,f#o等
..任意两个字符
.end匹配在字符串end前面的任意一个字符
注:如何匹配点号或句号?
答:在其前面使用反斜杠\进行转义
15.2.4 从字符串的开头或结尾或单词边界开始匹配(^/$ /\b /\B)
正则表达式模式匹配的字符串
^From 匹配任何以From开始的字符串
/bin/tesh$ 匹配任何以/bin/tcsh结束的字符串
^Subject: hi$ 匹配仅由Subject: hi组成的字符串
.*\$$ 匹配任何以美元符号$结尾的字符串
the 任何包含有'the'的字符串
\b 任何以"the"开始的字符串
\bthe\b 仅匹配单词"the"
\Bthe 任意包含"the"但不以"the"开头的单词
15.2.5 创建字符类([])
正则表达式匹配的字符串
b[aeiu]tbat,bet,bit,but
[cr][23][dp][o2]一个包含4个字符的字符串: 第一个字符是"r"或"c",后面是"2"或"3",以此类推
例如:c2do,r3p2,r2d2,c3po等
15.2.5 指定范围(-)和否定(^)
正则表达式模式匹配的字符
z.[0-9] 字符"z",后面跟任意一个字符,然后是一个十进制数字
[r-u][env-y][us] 略
[^aeiou] 一个非元音字符
[^\t\n] 除了TAB制表符和换行符意外的任意一个字符
["-a] 顺序值在'"'和"a"之间的任意一个字符,即顺序号在
34和97之间的某一个字符
15.2.6 使用闭包操作符(*,+,?,{})实现多次出现/重复匹配
[dn]ot? 字符"d"或"o",后面是一个"o",最后是最多一个字符"t",即,do,no,dot,not
0?[1-9] 从1到9中任意一位数字,前面可能还有一个"0"
[0-9]{15,16} 15或16位数字表示,例如:信用卡号码
]+> 匹配所有合法(和无效的)HTML标签字符串
[KQRBNP][a-h][1-8]-[a-h][1-8]
在"长代数"记谱法中,表示国际象棋合法的棋盘,K,Q,R等字幕后面加上两个用连 字符连起的"a1"到"h8"之前的棋盘坐标,前面的编号表示从哪里开始走棋,后面 代表走到哪个棋格位置去
15.2.7 特殊字符表示字符集
正则表达式模式匹配的字符串
\w+-\d+ 一个由字母或数字组成的字符串,和至少一个数字,两部分中间由连字符连接
[A-Za-z]\w* 第一个字符时字母,其余字符,是字母或数字
\d{3}-\d{3}-\d{4} 电话号码,前面带区号前缀,例如800-555-1212
\w+@\w+\.com 简单的[email protected]格式的电子邮件地址
15.2.8 用圆括号(())组建组
一对圆括号(())和正则表达式一起使用时可以实现以下任意一个功能:
对正则表达式进行分组匹配子组
正则表达式模式匹配的字符串
\d+(\.\d*)? 任意个十进制数+小数点+零或多个十进制数
(Mr?s?\.)?[A-Z][a-z]* [A-Za-z-]+ 首字母大写,其他字母小写,允许多个单词,横线,大写字母
15.3 正则表达式和Python语言
15.3.1 re模块:核心函数和方法
我们来看两个主要的函数/方法,match()和search(),以及compile()函数
常见的正则表达式函数与方法:
re模块的函数描述
compile(pattern,flags=0) 对正则表达式模式pattern进行编译,flags是可选标识符,并返回一个regex对象
re模块的函数和regex对象的方法
match(pattern,string,flags=0) 尝试用正则表达式模式pattern匹配字符串string,flags是可选标识符,如果匹配成功,则返回一个匹配对象,否则返回None
search(pattern,string,flags=0) 在字符串string中查找正则表达式模式pattern的第一次出现,flags是可选标识符,如果匹配成功,则返回一个匹配对象,否则返回None
findall(pattern,string[,flags]) 在字符串string中查找正则表达式模式pattern的所有(非重复)出现,返回一个匹配对象的列表
finditer(pattern,string[,flags]) 和findall()相同,但返回的不是列表而是迭代器,对于每个匹配,该迭代器返回一个匹配对象
15.3 常见的正则表达式函数与方法(继续)
函数/方法描述
匹配对象的方法
split(pattern,string,max=0) 根据正则表达式pattern中的分隔符把字符string分割为一个列表,返回成功匹配的列表,最多分割max次
sub(pattern,repl,string,max=0) 把字符串string中所有匹配正则pattern的地方替换成字符串repl,如果max的值没有给出,则对所有匹配的地方进行替换
group(num=0) 返回全部匹配对象或指定编号是num的子组
group() 返回一个包含全部匹配的子组的元祖
15.3.2 使用compile()编译正则表达式
15.3.3 匹配对象和group(),groups()方法
15.3.4 用match()匹配字符串
>>> import re
>>> m = re.match('foo','foo')
>>> if m is not None:
... m.group()
...
'foo'
m为一个匹配对象的实例:
>>> m
<_sre.SRE_Match object at 0x7f407788a030>
当匹配失败的例子,它返回None:
>>> m = re.match('foo','bar')
>>> if m is not None:
... m.group()
...
匹配失败,所以m被赋值为None
模式'foo'在字符串"food on the table"中找到一个匹配,因为它是从该字符串开头进行匹配
>>> m = re.match('foo','food on the table')
>>> m.group()
'foo'
利用Python语言面向对象,间接省略中间结果,将最终结果保存到一起
>>> re.match('foo','food on the table').group()
'foo'
注:上面如果匹配失败,会引发一个AttributeError异常
15.3.6 search()在一个字符串中查找一个模式(搜索与匹配的比较)
match()和search()区别在于match()会从字符串起始处进行匹配,search()会从字符串首次出现进行匹配
>>> m = re.match('foo','seafood')
>>> if m is not None: m.group()
...
>>> m = re.search('foo','seafood')
>>> if m is not None: m.group()
...
'foo'
15.3.6 匹配多个字符串(|)
>>> bt = 'bat|bet|bit'
>>> m = re.match(bt,'bat')
>>> if m is not None: m.group()
...
'bat'
>>> m =re.match(bt,'blt')
>>> if m is not None: m.group()
...
>>> m = re.match(bt,'He bit me!')
>>> if m is not None:m.group()
...
>>> m = re.search(bt,'He bit me!')
>>> if m is not None: m.group()
...
'bit'
15.3.7 匹配任意单个字符(.)
>>> anyend = '.end'
>>> m = re.match(anyend,'bend')#点号匹配'b'
>>> if m is not None: m.group()
...
'bend'
>>> m = re.match(anyend,'end')#没有字符匹配
>>> if m is not None:m.group()
...
>>> m = re.match(anyend, '\nend')#匹配字符(\n除外)
>>> if m is not None:m.group()
...
>>> m = re.search('.end','The end.')#匹配' '
>>> if m is not None:m.group()
...
' end'
在正则中,用反斜线对它进行转义,使点号失去它的特殊意义:
>>> patt314 = '3.14'#正则点号
>>> pi_patt = '3\.14'#浮点(小数点)
>>> m = re.match(pi_patt,'3.14') #完全匹配
>>> if m is not None: m.group()
...
'3.14'
>>> m = re.match(patt314,'3014')#点号匹配0
>>> if m is not None: m.group()
...
'3014'
>>> m = re.match(patt314,'3.14')#点号匹配'.'
>>> if m is not None:m.group()
...
'3.14'
15.3.8 创建字符集合([])
>>> m = re.match('[cr][23][dp][o2]','c3po')
>>> if m is not None:m.group()
...
'c3po'
>>> m = re.match('[cr][23][dp][o2]','c2do')
>>> if m is not None: m.group()
...
'c2do'
>>> m = re.match('r2d2|c3po','c2do')
>>> if m is not None: m.group()
...
>>> m = re.match('r2d2|c3po','r2d2')
>>> if m is not None: m.group()
...
'r2d2'
15.3.9 重复,特殊字符和子组
邮件地址支持域名前添加主机名功能:
>>> patt = '\w+@(\w+\.)?\w+\.com'
>>> re.match(patt,'[email protected]').group()
>>> re.match(patt,'[email protected]').group()
允许任意数量的子域名存在
>>> patt = '\w+@(\w+\.)*\w+\.com'
>>> re.match(patt,'[email protected]').group()
>>> import re
>>> m = re.match('\w\w\w-\d\d\d','abc-123')
>>> if m is not None:m.group()
...
'abc-123'
>>> import re
>>> m = re.match('\w\w\w-\d\d\d','abc-123')
>>> if m is not None:m.group()
...
'abc-123'
>>> m = re.match('\w\w\w-\d\d\d','abc-xyz')
>>> if m is not None: m.group()
...
使其分别提取包含字母或数字的部分和仅含数字的部分
>>> m = re.match('(\w\w\w)-(\d\d\d)','abc-123')
>>> m.group()
'abc-123'
>>> m.group(1)
'abc'
>>> m.group(2)
'123'
>>> m.groups()
('abc', '123')
子组的不同排列组合
>>> m = re.match('ab','ab')#无子组
>>> m.group()
'ab'
>>> m.groups()# 所有匹配的子组
()
>>> m = re.match('(ab)','ab')# 一个子组
>>> m.group()# 所有匹配
'ab'
>>> m.group(1)#匹配的子组1
'ab'
>>> m.groups()#所有匹配子组
('ab',)
>>> m = re.match('(a)(b)','ab')#两个子组
>>> m.group()
'ab'
>>> m.group(1)#匹配的子组1
'a'
>>> m.group(2)#匹配的子组2
'b'
>>> m.groups() #所有匹配子组的元祖
('a', 'b')
>>>
>>> m = re.match('(a(b))','ab')#两个子组
>>> m.group()#所有匹配的部分
'ab'
>>> m.group(1)#匹配的子组1
'ab'
>>> m.group(2)#匹配的子组2
'b'
>>> m.groups()#所有匹配的子组的元祖
('ab', 'b')
15.3.10 从字符串的开头或结尾匹配在单词边界上的匹配
>>> m = re.search('The','The end.')
>>> if m is not None: m.group()
...
'The'
>>> m = re.search('The','end. The')
>>> if m is not None: m.group()
...
'The'
>>> m = re.search(r'\bthe','bite the dog')
>>> if m is not None: m.group()
...
'the'
>>> m = re.search(r'\bthe','bitethe dog')
>>> if m is not None: m.group()
...
>>> m = re.search(r'\Bthe','bitethe dog')
>>> if m is not None: m.group()
...
'the'
15.3.11 用findall()找到每个出现的匹配部分
findall()返回一个列表,如果findall()没有找到匹配的部分,会返回空列表
>>> re.findall('car','car')
['car']
>>> re.findall('car','scary')
['car']
>>> re.findall('car','carry the barcardi to the car')
['car', 'car', 'car']
15.3.12 用sub()[和 subn()]进行搜索和替换
sub()和subn(),将某字符串中所有匹配正则模式的部分进行替换,用来替换的部分通常是一个字符串,也可能是一个函数,该函数返回一个用来替换的字符串
>>> re.sub('X','Mr.Smith','attn: X\n\nDear X,\n')
'attn: Mr.Smith\n\nDear Mr.Smith,\n'
>>> re.subn('X','Mr.Smith','attn: X\n\nDear X,\n')
('attn: Mr.Smith\n\nDear Mr.Smith,\n', 2)
>>> print re.sub('X','Mr.Smith','attn:X\n\nDear X,\n')
attn:Mr.Smith
Dear Mr.Smith,
>>> re.sub('[ae]','X','abcdef')
'XbcdXf'
>>> re.subn('[ae]','X','abcdef')
('XbcdXf', 2)
15.3.13 用split()分割
>>> re.split(':','str1:str2:str3')
['str1', 'str2', 'str3']
例,保存用户的登录信息(登录名,用户登录时的电传,登陆时间及地址)
# who > whodata.txt
# vi rewho.py
----------------------------------
#!/usr/bin/env python
import re
f = open('whodata.txt','r')
for eachLine in f.readlines():
print re.split('\s\s+',eachLine)
f.close
-----------------------------------
# python rewho.py
['root', 'tty1', '2013-12-03 00:33\n']
['root', 'pts/1', '2013-12-04 04:06 (192.168.8.2)\n']
例,unix下who命令输出结果进行分割(rewho.py)
# vi rewho1.py
-------------------------------
#!/usr/bin/env python
from os import popen
from re import split
f = popen('who','r')
for eachLine in f.readlines():
print split('\s\s+|\t',eachLine.strip())
f.close()
-------------------------------
下面的例子用来说明退格键"\b"和正则表达式"\b"(包含或不包含原始字符串)之间的区别:
>>> import re
>>> m = re.match('\bblow','blow')#退格键,没有匹配
>>> if m is not None: m.group()
...
>>> m = re.match('\\bblow','blow')#用\转义后,现在匹配了
>>> if m is not None: m.group()
...
'blow'
>>> m = re.match(r'\bblow','blow')#改用原始字符串
>>> if m is not None: m.group()
...
'blow'
15.4 正则表达式示例:
例,正则联系的数据生成代码
为联系使用正则生成随机数据,并将产生的数据输出到屏幕
# vi gendata.py #
----------------------------------
#!/usr/bin/env python
from random import randint, choice, randrange
from string import lowercase
from sys import maxint
from time import ctime
doms = ("com","edu", "net","org","gov")
fobj = open("redata.txt","a+")
for i in range(randint(5,10)):
#dtint = randint(0, maxint - 1)
dtint = randrange(2**32)
dtstr = ctime(dtint)
shorter = randint(4, 7)
em = ""
for j in range(shorter):
em += choice(lowercase)
longer = randint(shorter, 12)
dn = ""
for j in range(longer):
dn += choice(lowercase)
fobj.write("%s::%s@%s.%s::%d-%d-%d\n" % (dtstr, em, dn, choice(doms), dtint,
shorter, longer))
fobj.close()
----------------------------------
# python gendata.py
# cat gendata.py
-------------------------------------
# cat redata.txt
Wed Dec 19 21:38:05 1984::[email protected]::472311485-5-9
Sun Nov 28 10:37:21 1971::[email protected]::60147441-5-9
Sat Mar 23 00:14:13 2080::[email protected]::3478349653-7-12
Fri Aug 9 18:53:53 1996::[email protected]::839588033-7-12
Thu Oct 3 12:32:07 2069::[email protected]::3148000327-5-10
Tue Sep 16 12:30:29 2070::[email protected]::3178067429-5-7
Tue May 10 23:45:35 2061::[email protected]::2882965535-5-7
Mon Dec 3 12:28:38 2007::[email protected]::1196656118-4-6
Fri May 29 04:24:41 2020::[email protected]::1590697481-6-7
Fri Sep 22 17:25:03 1972::[email protected]::86005503-4-11
Wed Nov 29 18:11:33 2006::[email protected]::1164795093-4-6
Sun Jun 19 13:34:50 1977::[email protected]::235550090-5-5
Sat Sep 12 11:44:45 2009::[email protected]::1252727085-5-6
Tue Dec 1 17:21:46 2093::[email protected]::3910497706-5-11
Thu Aug 19 14:08:40 2010::[email protected]::1282198120-4-6
Sun Nov 1 14:44:05 1998::[email protected]::909902645-4-8
Thu Sep 11 21:39:14 2059::[email protected]::2830513154-4-4
Wed Oct 22 13:01:19 2053::[email protected]::2644722079-4-5
Thu Apr 27 01:43:14 2051::[email protected]::2566143794-6-11
Sun Dec 14 00:15:46 2087::[email protected]::3722170546-6-11
Tue Sep 6 23:48:58 2061::[email protected]::2893247338-5-5
Sat Apr 24 14:28:42 2010::[email protected]::1272090522-4-10
Tue Apr 17 12:05:06 2096::[email protected]::3985473906-7-10
Mon Dec 27 13:32:20 2077::[email protected]::3407808740-4-6
Fri Jul 4 06:07:54 2098::[email protected]::4055263674-5-8
-------------------------------------
15.4.1 匹配一个字符串
在第一个例子中,我们将写一个正则表达式,用它从文件readate.txt的每一行中(仅)提取时间戳中有关星期的数据字段,我们将用到以下正则:
"^Mon|^Tue|^Wed|^Thu|^Fri|^Sat|^Sun"
或只用一个"^"
"^(Mon|Tue|Wed|Thu|Fri|Sat|Sun)"
例:
>>> import re
>>> data = 'Sat Apr 24 14:28:42 2010::[email protected]::1272090522-4-10'
>>> patt = "^(Mon|Tue|Wed|Thu|Fri|Sat|Sun)"
>>> m = re.match(patt, data)
>>> m.group()
'Sat'
>>> m.group(1)
'Sat'
>>> m.groups()
('Sat',)
例,要求字符串以三个由字符或数字组成的字符做开头
>>> patt = '^(\w{3})'
>>> m =re.match(patt,data)
>>> if m is not None: m.group()
...
'Sat'
>>> m.group(1)
'Sat'
如果把{3}写在圆括号外((\w){3}),就变成三个连续的单个由字符或数字组成的字
符
>>> patt = '^(\w){3}'
>>> m = re.match(patt, data)
>>> if m is not None:m.group()
...
'Sat'
>>> m.group(1)
't'
15.4.2 搜索与匹配的比较,"贪婪"匹配
查找三个由连字符号(-)分隔的整数集
>>> patt = '\d+-\d+-\d+'
>>> re.search(patt, data).group()
'1272090522-4-10'
匹配全部字符串的正则表达式,用".+"来标识任意个字符集
>>> patt = '.+\d+-\d+-\d+'
>>> re.match(patt, data).group()
'Sat Apr 24 14:28:42 2010::[email protected]::1272090522-4-10'
获取每行末尾数字的字段:
>>> patt = '.+(\d+-\d+-\d+)'
>>> re.match(patt, data).group(1)
'2-4-10'
正则表达式本身是贪心匹配的,通配字在从左到右求值时会尽量抓取满足匹配的最长字符串, ".+"会从字符串起始处抓取模式最长字符,\d+只需要一位数字,从而不会影响\d+的匹配,所以他匹配了最右边的2
一个解决办法是用"非贪婪"操作符,"?",他的作用是要求正则引擎匹配的字符越少越好
>>> patt = '.+?(\d+-\d+-\d+)'
>>> re.match(patt, data).group(1)
'1272090522-4-10'
抽取三个整数字段里中间那个整数部分
>>> patt = '-(\d+)-'
>>> m = re.search(patt,data)
>>> m.group()
'-4-'
>>> m.group(1)
'4'