Python正则表达式re模块简明笔记.docx

Python正则表达式re模块简明笔记.docx

《Python正则表达式re模块简明笔记.docx》由会员分享，可在线阅读，更多相关《Python正则表达式re模块简明笔记.docx（16页珍藏版）》请在冰豆网上搜索。

Python正则表达式re模块简明笔记

Python正则表达式re模块简明笔记

Python正则表达式re模块简明笔记

要注意的是，正则表达式并不是一个程序，而是用于处理字符串的一种模式，如果你想用它来处理字符串，就必须使用支持正则表达式的工具，比如Linux中的awk,sed,grep，或者编程语言Perl,Python,Java等等。

作者：

FunHacks来源：

FunHacks|2016-12-2811:

20

 收藏

  分享

简介

正则表达式（regularexpression）是可以匹配文本片段的模式。

最简单的正则表达式就是普通字符串，可以匹配其自身。

比如，正则表达式‘hello’可以匹配字符串‘hello’。

要注意的是，正则表达式并不是一个程序，而是用于处理字符串的一种模式，如果你想用它来处理字符串，就必须使用支持正则表达式的工具，比如Linux中的awk,sed,grep，或者编程语言Perl,Python,Java等等。

正则表达式有多种不同的风格，下表列出了适用于Python或Perl等编程语言的部分元字符以及说明：

re模块

在Python中，我们可以使用内置的re模块来使用正则表达式。

有一点需要特别注意的是，正则表达式使用 \ 对特殊字符进行转义，比如，为了匹配字符串‘python.org’，我们需要使用正则表达式 'python\.org'，而Python的字符串本身也用 \ 转义，所以上面的正则表达式在Python中应该写成 'python\\.org'，这会很容易陷入 \ 的困扰中，因此，我们建议使用Python的原始字符串，只需加一个r前缀，上面的正则表达式可以写成：

r'python\.org'

re模块提供了不少有用的函数，用以匹配字符串，比如：

∙compile函数

∙match函数

∙search函数

∙findall函数

∙finditer函数

∙split函数

∙sub函数

∙subn函数

re模块的一般使用步骤如下：

∙使用compile函数将正则表达式的字符串形式编译为一个Pattern对象

∙通过Pattern对象提供的一系列方法对文本进行匹配查找，获得匹配结果（一个Match对象）

∙最后使用Match对象提供的属性和方法获得信息，根据需要进行其他的操作

compile函数

compile函数用于编译正则表达式，生成一个Pattern对象，它的一般使用形式如下：

pile（pattern[,flag]）

其中，pattern是一个字符串形式的正则表达式，flag是一个可选参数，表示匹配模式，比如忽略大小写，多行模式等。

下面，让我们看看例子。

importre

#将正则表达式编译成Pattern对象

pattern=pile（r'\d+'）

在上面，我们已将一个正则表达式编译成Pattern对象，接下来，我们就可以利用pattern的一系列方法对文本进行匹配查找了。

Pattern对象的一些常用方法主要有：

∙match方法

∙search方法

∙findall方法

∙finditer方法

∙split方法

∙sub方法

∙subn方法

match方法

>>>m=pattern.search（'one12twothree34four'） #这里如果使用match方法则不匹配

>>>m

<_sre.SRE_Matchobjectat0x10cc03ac0>

>>>m.group（）

'12'

>>>m=pattern.search（'one12twothree34four',10,30） #指定字符串区间

>>>m

<_sre.SRE_Matchobjectat0x10cc03b28>

>>>m.group（）

'34'

>>>m.span（）

（13,15）

再来看一个例子：

#-*-coding:

utf-8-*-

importre

#将正则表达式编译成Pattern对象

pattern=pile（r'\d+'）

#使用search（）查找匹配的子串，不存在匹配的子串时将返回None

#这里使用match（）无法成功匹配

m=pattern.search（'hello123456789'）

ifm:

   #使用Match获得分组信息

   print'matchingstring:

',m.group（）

   print'position:

',m.span（）

执行结果：

matchingstring:

123456

position:

（6,12）

findall方法

上面的match和search方法都是一次匹配，只要找到了一个匹配的结果就返回。

然而，在大多数时候，我们需要搜索整个字符串，获得所有匹配的结果。

findall方法的使用形式如下：

findall（string[,pos[,endpos]]）

其中，string是待匹配的字符串，pos和endpos是可选参数，指定字符串的起始和终点位置，默认值分别是0和len（字符串长度）。

findall以列表形式返回全部能匹配的子串，如果没有匹配，则返回一个空列表。

看看例子：

importre

pattern=pile（r'\d+'）  #查找数字

result1=pattern.findall（'hello123456789'）

result2=pattern.findall（'one1two2three3four4',0,10）

printresult1

printresult2

执行结果：

['123456','789']

['1','2']

finditer方法

finditer方法的行为跟findall的行为类似，也是搜索整个字符串，获得所有匹配的结果。

但它返回一个顺序访问每一个匹配结果（Match对象）的迭代器。

看看例子：

#-*-coding:

utf-8-*-

importre

pattern=pile（r'\d+'）

result_iter1=pattern.finditer（'hello123456789'）

result_iter2=pattern.finditer（'one1two2three3four4',0,10）

printtype（result_iter1）

printtype（result_iter2）

print'result1...'

form1inresult_iter1:

  #m1是Match对象

   print'matchingstring:

{},position:

{}'.format（m1.group（）,m1.span（））

print'result2...'

form2inresult_iter2:

   print'matchingstring:

{},position:

{}'.format（m2.group（）,m2.span（））

执行结果：

result1...

matchingstring:

123456,position:

（6,12）

matchingstring:

789,position:

（13,16）

result2...

matchingstring:

1,position:

（3,4）

matchingstring:

2,position:

（7,8）

split方法

split方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：

split（string[,maxsplit]）

其中，maxsplit用于指定最大分割次数，不指定将全部分割。

看看例子：

importre

p=pile（r'[\s\,\;]+'）

printp.split（'a,b;;c  d'）

执行结果：

['a','b','c','d']

sub方法

sub方法用于替换。

它的使用形式如下：

sub（repl,string[,count]）

其中，repl可以是字符串也可以是一个函数：

∙如果repl是字符串，则会使用repl去替换字符串每一个匹配的子串，并返回替换后的字符串，另外，repl还可以使用 \id 的形式来引用分组，但不能使用编号0；

∙如果repl是函数，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。

count用于指定最多替换次数，不指定时全部替换。

看看例子：

importre

p=pile（r'（\w+）（\w+）'）

s='hello123,hello456'

deffunc（m）:

   return'hi'+''+m.group

（2）

printp.sub（r'helloworld',s） #使用'helloworld'替换'hello123'和'hello456'

printp.sub（r'\2\1',s）       #引用分组

printp.sub（func,s）

printp.sub（func,s,1）        #最多替换一次

执行结果：

helloworld,helloworld

123hello,456hello

hi123,hi456

hi123,hello456

subn方法

subn方法跟sub方法的行为类似，也用于替换。

它的使用形式如下：

subn（repl,string[,count]）

它返回一个元组：

（sub（repl,string[,count]）,替换次数）

元组有两个元素，第一个元素是使用sub方法的结果，第二个元素返回原字符串被替换的次数。

看看例子：

importre

p=pile（r'（\w+）（\w+）'）

s='hello123,hello456'

deffunc（m）:

   return'hi'+''+m.group

（2）

printp.subn（r'helloworld',s）

printp.subn（r'\2\1',s）

printp.subn（func,s）

printp.subn（func,s,1）

执行结果：

（'helloworld,helloworld',2）

（'123hello,456hello',2）

（'hi123,hi456',2）

（'hi123,hello456',1）

其他函数

事实上，使用compile函数生成的Pattern对象的一系列方法跟re模块的多数函数是对应的，但在使用上有细微差别。

match函数

match函数的使用形式如下：

re.match（pattern,string[,flags]）:

其中，pattern是正则表达式的字符串形式，比如 \d+, [a-z]+。

而Pattern对象的match方法使用形式是：

match（string[,pos[,endpos]]）

可以看到，match函数不能指定字符串的区间，它只能搜索头部，看看例子：

importre

m1=re.match（r'\d+','One12twothree34four'）

ifm1:

   print'matchingstring:

',m1.group（）

else:

   print'm1is:

',m1

m2=re.match（r'\d+','12twothree34four'）

ifm2:

   print'matchingstring:

',m2.group（）

else:

   print'm2is:

',m2

执行结果：

m1is:

None

matchingstring:

12

search函数

search函数的使用形式如下：

re.search（pattern,string[,flags]）

search函数不能指定字符串的搜索区间，用法跟Pattern对象的search方法类似。

findall函数

findall函数的使用形式如下：

re.findall（pattern,string[,flags]）

findall函数不能指定字符串的搜索区间，用法跟Pattern对象的findall方法类似。

看看例子：

importre

printre.findall（r'\d+','hello12345789'）

#输出

['12345','789']

finditer函数

finditer函数的使用方法跟Pattern的finditer方法类似，形式如下：

re.finditer（pattern,string[,flags]）

split函数

split函数的使用形式如下：

re.split（pattern,string[,maxsplit]）

sub函数

sub函数的使用形式如下：

re.sub（pattern,repl,string[,count]）

subn函数

subn函数的使用形式如下：

re.subn（pattern,repl,string[,count]）

到底用哪种方式

从上文可以看到，使用re模块有两种方式：

∙使用pile函数生成一个Pattern对象，然后使用Pattern对象的一系列方法对文本进行匹配查找；

∙直接使用re.match,re.search和re.findall等函数直接对文本匹配查找；

下面，我们用一个例子展示这两种方法。

先看第1种用法：

importre

#将正则表达式先编译成Pattern对象

pattern=pile（r'\d+'）

printpattern.match（'123,123'）

printpattern.search（'234,234'）

printpattern.findall（'345,345'）

再看第2种用法：

importre

printre.match（r'\d+','123,123'）

printre.search（r'\d+','234,234'）

printre.findall（r'\d+','345,345'）

如果一个正则表达式需要用到多次（比如上面的 \d+），在多种场合经常需要被用到，出于效率的考虑，我们应该预先编译该正则表达式，生成一个Pattern对象，再使用该对象的一系列方法对需要匹配的文件进行匹配；而如果直接使用re.match,re.search等函数，每次传入一个正则表达式，它都会被编译一次，效率就会大打折扣。

因此，我们推荐使用第1种用法。

匹配中文

在某些情况下，我们想匹配文本中的汉字，有一点需要注意的是，中文的unicode编码范围 主要在 [\u4e00-\u9fa5]，这里说主要是因为这个范围并不完整，比如没有包括全角（中文）标点，不过，在大部分情况下，应该是够用的。

假设现在想把字符串 title=u'你好，hello，世界' 中的中文提取出来，可以这么做：

#-*-coding:

utf-8-*-

importre

title=u'你好，hello，世界'

pattern=pile（ur'[\u4e00-\u9fa5]+'）

result=pattern.findall（title）

printresult

注意到，我们在正则表达式前面加上了两个前缀 ur，其中 r 表示使用原始字符串，u 表示是unicode字符串。

执行结果:

[u'\u4f60\u597d',u'\u4e16\u754c']

贪婪匹配

在Python中，正则匹配默认是贪婪匹配（在少数语言中可能是非贪婪），也就是匹配尽可能多的字符。

比如，我们想找出字符串中的所有 div 块：

importre

content='aa

pattern=pile（r'

result=pattern.findall（content）

printresult

执行结果：

['

由于正则匹配是贪婪匹配，也就是尽可能多的匹配，因此，在成功匹配到第一个