[PYTHON]核心编程笔记(15.Py

核心笔记:查找与匹配的比较

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           简单的XXX@YYY.com格式的电子邮件地址

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,'nobody@xxx.com').group()

'nobody@xxx.com'

>>> re.match(patt,'nobody@www.xxx.com').group()

'nobody@www.xxx.com'

允许任意数量的子域名存在

>>> patt = '\w+@(\w+\.)*\w+\.com'

>>> re.match(patt,'nobody@www.xxx.yyy.zzz.com').group()

'nobody@www.xxx.yyy.zzz.com'

>>> 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::cjszt@qernrsuky.net::472311485-5-9

Sun Nov 28 10:37:21 1971::kamio@dakqcxbvy.com::60147441-5-9

Sat Mar 23 00:14:13 2080::jewsdjf@gspwmknizxka.net::3478349653-7-12

Fri Aug  9 18:53:53 1996::slgizll@smhtzuezdtmj.edu::839588033-7-12

Thu Oct  3 12:32:07 2069::octlv@xzpcevioxo.edu::3148000327-5-10

Tue Sep 16 12:30:29 2070::zipap@xjcbiqh.org::3178067429-5-7

Tue May 10 23:45:35 2061::jdfge@ouihivz.net::2882965535-5-7

Mon Dec  3 12:28:38 2007::tvxh@ebsmwv.com::1196656118-4-6

Fri May 29 04:24:41 2020::fxewqf@yyvoenn.gov::1590697481-6-7

Fri Sep 22 17:25:03 1972::xamv@cxtvyflhjwi.net::86005503-4-11

Wed Nov 29 18:11:33 2006::bgrn@demuxw.net::1164795093-4-6

Sun Jun 19 13:34:50 1977::sktyy@weeah.edu::235550090-5-5

Sat Sep 12 11:44:45 2009::hzhew@vojacf.com::1252727085-5-6

Tue Dec  1 17:21:46 2093::opszu@xrnnkrqgjzh.com::3910497706-5-11

Thu Aug 19 14:08:40 2010::hqug@wqampb.com::1282198120-4-6

Sun Nov  1 14:44:05 1998::xgpk@xhbmddyp.org::909902645-4-8

Thu Sep 11 21:39:14 2059::iebr@tymv.com::2830513154-4-4

Wed Oct 22 13:01:19 2053::vabh@pjuds.org::2644722079-4-5

Thu Apr 27 01:43:14 2051::qpuypk@mforupzffpd.gov::2566143794-6-11

Sun Dec 14 00:15:46 2087::dwnaxc@qosofckdcwt.gov::3722170546-6-11

Tue Sep  6 23:48:58 2061::iiwkg@pohvb.org::2893247338-5-5

Sat Apr 24 14:28:42 2010::gsdm@ccxvgwzkkg.org::1272090522-4-10

Tue Apr 17 12:05:06 2096::zzztpky@fetykwmptk.gov::3985473906-7-10

Mon Dec 27 13:32:20 2077::jgst@kpvdga.gov::3407808740-4-6

Fri Jul  4 06:07:54 2098::hhvvt@mnzpvlua.gov::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::gsdm@ccxvgwzkkg.org::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::gsdm@ccxvgwzkkg.org::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'