Python正则表达式-总结

总结--常用正则表达式符号

'.'默认匹配除\n之外的任意一个字符，若指定flagDOTALL,则匹配任意字符，包括换行

'^'匹配字符开头，若指定flagsMULTILINE,这种也可以匹配上(r"^a","\nabc\neee",flags=re.MULTILINE)

'$'匹配字符结尾，或e.search("foo$","bfoo\nsdfsf",flags=re.MULTILINE).group()也可以

'*'匹配*号前的字符0次或多次，re.findall("ab*","cabb3abcbbac")结果为['abb','ab','a']

'+'匹配前一个字符1次或多次，re.findall("ab+","ab+cd+abb+bba")结果['ab','abb']

'?'匹配前一个字符1次或0次

'{m}'匹配前一个字符m次

'{n,m}'匹配前一个字符n到m次，re.findall("ab{1,3}","abbabcabbcbbb")结果'abb','ab','abb']

'|'匹配|左或|右的字符，re.search("abc|ABC","ABCBabcCD").group()结果'ABC'

'(...)'分组匹配，re.search("(abc){2}a(123|456)c","abcabca456c").group()结果abcabca456c

'\A'只从字符开头匹配，re.search("\Aabc","alexabc")是匹配不到的

'\Z'匹配字符结尾，同$

'\d'匹配数字0-9

'\D'匹配非数字

'\w'匹配[A-Za-z0-9]

'\W'匹配非[A-Za-z0-9]

's'匹配空白字符、\t、\n、\r,re.search("\s+","ab\tc1\n3").group()结果'\t'

'(?P<name>...)'分组匹配

re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{4})","371481199306143242").groupdict("city")

结果{'province':'3714','city':'81','birthday':'1993'}

[/code]总结--最常用的匹配语法

re.match从头开始匹配

re.search匹配包含

re.findall把所有匹配到的字符放到以列表中的元素返回

re.splitall以匹配到的字符当做列表分隔符

re.sub匹配字符并替换

[/code]

Python中字符串前面加上r表示原生字符串[code]在Python的string前面加上‘r’，是为了告诉编译器这个string是个rawstring，

不要转意backslash'\'。

例如，\n在rawstring中，是两个字符，\和n，而不会转意为换行符。

由于正则表达式和\会有冲突，因此，当一个字符串使用了正则表达式后，最好在前面加上'r'。

[/code]反斜杠的困扰与大多数编程语言相同，正则表达式里使用"\"作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符"\"，那么使用编程语言表示的正则表达式里将需要4个反斜杠"\\\\"：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r"\\"表示。同样，匹配一个数字的"\\d"可以写成r"\d"。有了原生字符串，你再也不用担心是不是漏写了反斜杠，写出来的表达式也更直观。总结--最常用的几个匹配模式

re.I(re.IGNORECASE):忽略大小写（括号内是完整写法，下同）

M(MULTILINE):多行模式，改变'^'和'$'的行为

S(DOTALL):点任意匹配模式，改变'.'的行为

[/code]正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。Python自1.5版本起增加了re模块，它提供Perl风格的正则表达式模式。re模块--使Python语言拥有全部的正则表达式功能。compile函数--根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。re模块--也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。本文主要介绍Python中常用的正则表达式处理函数。

re.match函数

re.match尝试从字符串的开始匹配一个模式。函数语法：

re.match(pattern,string,flags=0)

[/code]函数参数说明：

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

匹配成功re.match方法返回一个匹配的对象，否则返回None。我们可以使用group(num)或groups()匹配对象函数来获取匹配表达式。

匹配对象方法	描述
group(num=0)	匹配的整个表达式的字符串，group()可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()	返回一个包含所有小组字符串的元组，从1到所含的小组号。

实例：

#!/usr/bin/python

importre

line="Catsaresmarterthandogs"

matchObj=re.match(r'(.*)are(.*?).*',line,re.M|re.I)

ifmatchObj:

print("matchObj.group():",matchObj.group())

print("matchObj.group(1):",matchObj.group(1))

print("matchObj.group(2):",matchObj.group(2))

else:

print("Nomatch!!")

[/code]以上实例执行结果如下：

matchObj.group():Catsaresmarterthandogs

matchObj.group(1):Cats

matchObj.group(2):smarter

[/code]

re.search方法

re.match尝试从字符串的开始匹配一个模式。函数语法：

re.search(pattern,string,flags=0)

[/code]函数参数说明：

参数	描述
pattern	匹配的正则表达式
string	要匹配的字符串。
flags	标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

匹配成功re.search方法方法返回一个匹配的对象，否则返回None。我们可以使用group(num)或groups()匹配对象函数来获取匹配表达式。

匹配对象方法	描述
group(num=0)	匹配的整个表达式的字符串，group()可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups()	返回一个包含所有小组字符串的元组，从1到所含的小组号。

实例：

#!/usr/bin/python

importre

line="Catsaresmarterthandogs"

searchObj=re.search(r'(.*)are(.*?).*',line,re.M|re.I)

ifsearchObj:

print("searchObj.group():",searchObj.group())

print("searchObj.group(1):",searchObj.group(1))

print("searchObj.group(2):",searchObj.group(2))

else:

print("Nosearch!!")

[/code]以上实例执行结果如下：

searchObj.group():Catsaresmarterthandogs

searchObj.group(1):Cats

searchObj.group(2):smarter

[/code]

re.match与re.search的区别

re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。实例：

#!/usr/bin/python

importre

line="Catsaresmarterthandogs";

matchObj=re.match(r'dogs',line,re.M|re.I)

ifmatchObj:

print("match-->matchObj.group():",matchObj.group())

else:

print("Nomatch!!")

matchObj=re.search(r'dogs',line,re.M|re.I)

ifmatchObj:

print("search-->matchObj.group():",matchObj.group())

else:

print("Nomatch!!")

[/code]以上实例运行结果如下：

Nomatch!!

search-->matchObj.group():dogs

[/code]

检索和替换

Python的re模块提供了re.sub用于替换字符串中的匹配项。语法：

re.sub(pattern,repl,string,count=0,flags=0)

[/code]返回的字符串是在字符串中用RE最左边不重复的匹配来替换。如果模式没有发现，字符将被没有改变地返回。可选参数count是模式匹配后替换的最大次数；count必须是非负整数。缺省值是0表示替换所有的匹配。实例：

#!/usr/bin/python

importre

phone="2004-959-559#ThisisPhoneNumber"

#DeletePython-stylecomments

num=re.sub(r'#.*$',"",phone)

print("PhoneNum:",num)

#Removeanythingotherthandigits

num=re.sub(r'\D',"",phone)

print("PhoneNum:",num)

[/code]以上实例执行结果如下：

PhoneNum:2004-959-559

PhoneNum:2004959559

[/code]

正则表达式修饰符-可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位OR(|)它们来指定。如re.I|re.M被设置成I和M标志：

修饰符	描述
re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响^和$
re.S	使.匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响\w,\W,\b,\B.
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

正则表达式模式

模式字符串使用特殊的语法来表示一个正则表达式：字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。多数字母和数字前加一个反斜杠时会拥有不同的含义。标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。反斜杠本身需要使用反斜杠转义。由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如r'/t'，等价于'//t')匹配相应的特殊字符。下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。

正则表达式的符号与方法

常用符号：点号，星号，问号与括号（小括号）

.:匹配任意字符，换行符\n除外

*:匹配前一个字符0次或无限次

?:匹配前一个字符0次或1次

.*:贪心算法

.*?:非贪心算法

():括号内的数据作为结果返回

常用方法：findall，search，sub

findall：匹配所有符合规律的内容，返回包含结果的列表

search：匹配并提取第一个规律的内容，返回一个正则表达式对象(object)

sub：替换符合规律的内容，返回替换后的值

[/code]

表1.常用的元字符

代码	说明
.	匹配除换行符以外的任意字符
\w	匹配字母或数字或下划线或汉字
\s	匹配任意的空白符
\d	匹配数字
\b	匹配单词的开始或结束
^	匹配字符串的开始
$	匹配字符串的结束

表2.常用的限定符

代码/语法	说明
*	重复零次或更多次
+	重复一次或更多次
?	重复零次或一次
{n}	重复n次
{n,}	重复n次或更多次
{n,m}	重复n到m次

表3.常用的反义代码

代码/语法	说明
\W	匹配任意不是字母，数字，下划线，汉字的字符
\S	匹配任意不是空白符的字符
\D	匹配任意非数字的字符
\B	匹配不是单词开头或结束的位置
[^x]	匹配除了x以外的任意字符
[^aeiou]	匹配除了aeiou这几个字母以外的任意字符

表4.常用分组语法

分类	代码/语法	说明
捕获	(exp)	匹配exp,并捕获文本到自动命名的组里
(?<name>exp)	匹配exp,并捕获文本到名称为name的组里，也可以写成(?'name'exp)
(?:exp)	匹配exp,不捕获匹配的文本，也不给此分组分配组号
零宽断言	(?=exp)	匹配exp前面的位置
(?<=exp)	匹配exp后面的位置
(?!exp)	匹配后面跟的不是exp的位置
(?<!exp)	匹配前面不是exp的位置
注释	(?#comment)	这种类型的分组不对正则表达式的处理产生任何影响，用于提供注释让人阅读

表5.懒惰限定符

代码/语法	说明
*?	重复任意次，但尽可能少重复
+?	重复1次或更多次，但尽可能少重复
??	重复0次或1次，但尽可能少重复
{n,m}?	重复n到m次，但尽可能少重复
{n,}?	重复n次以上，但尽可能少重复

1)findall

a.点号

.

importre

a='xzx23'

b=re.findall('x.',a)

printb

[/code]

输出

['xz','x2']

[/code]点

.

是一个占位符，一个

.

代表一个符号

b.星号

*

importre

a='xyxy123'

b=re.findall('x*',a)

print(b)

[/code]输出

['x','','x','','','','','']

[/code]

依次匹配字符，有则显示，无则显示

''

(空)。

c.问号

?

importre

a='xy123'

b=re.findall('x?',a)

print(b)

[/code]输出

['x','','','','','']

[/code]单独与

*

一样，前面附加其他的符号将做非贪心限制

d.贪心

.*

importre

secret_code='ghkj08hs68xxIxxa14kgj4w314exxlovexxbvk14rgjhxxyouxxfj4286ykjhag2'

b=re.findall('xx.*xx',secret_code)

print(b)

[/code]输出

['xxIxxa14kgj4w314exxlovexxbvk14rgjhxxyouxx']

[/code]只要满足条件全部显示，贪心算法e.非贪心

.*?

importre

secret_code='ghkj08hs68xxIxxa14kgj4w314exxlovexxbvk14rgjhxxyouxxfj4286ykjhag2'

b=re.findall('xx.*?xx',secret_code)

print(b)

[/code]输出

['xxIxx','xxlovexx','xxyouxx']

[/code]以上只做了解，一般只用（.*?）

f.经典用法

(.*?)

importre

secret_code='ghkj08hs68xxIxxa14kgj4w314exxlovexxbvk14rgjhxxyouxxfj4286ykjhag2'

b=re.findall('xx(.*?)xx',secret_code)

print(b)

[/code]输出

['I','love','you']

[/code]

()

包围所需要的内容，括号内的内容作为结果返回，不需要的内容放在括号外面

2)re.S

importre

secret_code='''ghkj08hs68xxIxxa14kgj4w314exxlove

xxbvk14rgjhxxyouxxfj4286ykjhag2'''

#love后有换行符

b=re.findall('xx(.*?)xx',secret_code)

print(b)

#因为.不能匹配换行符。所以会一行为一个搜索项去找。匹配任何字符除了新的一行

[/code]输出

['I','bvk14rgjh']

[/code]

re.S

importre

secret_code='''ghkj08hs68xxIxxa14kgj4w314exxlove

xxbvk14rgjhxxyouxxfj4286ykjhag2'''

#love后有换行符

b=re.findall('xx(.*?)xx',secret_code,re.S)

print(b)

#re.S让.匹配所有行，包括了换行符（以\n的形式出现）

[/code]输出

['I','love\n','you']

[/code]

3)search

对比search和findall的区别

search找到一个后返回，不继续，大大提高效率

findall遍历全部，找到尽可能多的项

[/code]

importre

s2='''ghkj08hs68xxIxx123xxlove

xxbvk14rgjhxxfj4286ykjhag2'''

b=re.search('xx(.*?)xx(.*?)xx',s2,re.S).group(1)

print(b)

c=re.search('xx(.*?)xx(.*?)xx',s2,re.S).group(2)

print(c)

d=re.search('xx(.*?)xx(.*?)xx',s2,re.S).group(3)

print(d)

[/code]输出

Traceback(mostrecentcalllast):

File"D:/WorkSpace/python/Django/test.py",line7,in<module>

d=re.search('xx(.*?)xx(.*?)xx',s2,re.S).group(3)

IndexError:nosuchgroup

I

123

[/code]

group

是按括号顺序匹配

importre

s2='''ghkj08hs68xxIxx123xxlovexxbvk14rgjhxxfj4286ykjhag2'''

f2=re.findall('xx(.*?)xx123xx(.*?)xx',s2,re.S)

print(f2)

print(f2[0][1])

[/code]输出

[('I','love')]

love

[/code]每一个匹配项为第一级列表，括号为二级列表

4)sub

re.sub(pattern,repl,string,count=0,flags=0)

找到RE匹配的所有子串，并将其用一个不同的字符串替换。

第一个参数：pattern

pattern，表示正则中的模式字符串

第二个参数：repl

repl，就是replacement，被替换，的字符串的意思。

第三个参数：string

string，即表示要被处理，要被替换的那个string字符串。

第四个参数：可选参数count是模式匹配後替换的最大次数；count必须是非负整数。缺省值是0表示替换所有的匹配。如果无匹配，字符串将会无改变地返回。

[/code]

re.subn(pattern,repl,string,count=0,flags=0)

与re.sub方法作用一样，但返回的是包含新字符串和替换执行次数的两元组。

importre

s='123abcssfasdfas123'

output=re.sub('123(.*?)123','123789123',s)

print(output)

#sub将符合条件的()内内容提换

[/code]输出

123789123

[/code]

importre

inputStr="hello123world456"

replacedStr=re.sub("\d+","222",inputStr)

print(replacedStr)

[/code]输出

hello222world222

[/code]

5)注意：

fromreimportfindall,search,S

最好不要引入，因为S等容易和变量等混淆，引起歧义

[/code]

6)compile用法

importre

secret_code='''ghkj08hs68xxIxxa14kgj4w314exxlove

xxbvk14rgjhxxyouxxfj4286ykjhag2'''

pattern='xx(.*?)xx'

new_pattern=re.compile(pattern,re.S)

b=re.findall(new_pattern,secret_code)

print(b)

[/code]输出

['I','love\n','you']

[/code]因为findall自动调用compile方法，所以不先编译规律compile再匹配

7)匹配纯数字(\d+)

importre

a='dfhkgh43gfhja873y5t2167715'

b=re.findall('(\d+)',a)

print(b)

[/code]输出

['43','873','5','2167715']

[/code]

2.应用举例

1)用findall和search从大量文本中匹配内容

a.提取标题

importre

old_url='http://www.jikexueyuan.com/course/android/?pageNum=2'

total_page=20

f=open('text.txt','r')

html=f.read()

f.close()

title=re.search('<title>(.*?)</title>',html,re.S).group(1)

printtitle

[/code]

text.txt

<html>

<head>

<title>极客学院爬虫测试</title>

</head>

<body>

<divclass="topic"><ahref="http://jikexueyuan.com/welcome.html">欢迎参加《Python定向爬虫入门》</a>

<divclass="list">

<ul>

<li><ahref="http://jikexueyuan.com/1.html">这是第一条</a></li>

<li><ahref="http://jikexueyuan.com/2.html">这是第二条</a></li>

<li><ahref="http://jikexueyuan.com/3.html">这是第三条</a></li>

</ul>

</div>

</div>

</body>

</html>

[/code]输出

极客学院爬虫测试

[/code]

b.提取网址

link=re.findall('href="(.*?)"',html,re.S)

foreachinlink:

printeach

[/code]

输出

http://jikexueyuan.com/welcome.html

http://jikexueyuan.com/1.html

http://jikexueyuan.com/2.html

http://jikexueyuan.com/3.html

[/code]

c.提取文字信息

先爬大再爬小

text_fied=re.findall('<ul>(.*?)</ul>',html,re.S)[0]

the_text=re.findall('">(.*?)</a>',text_fied,re.S)

forevery_textinthe_text:

printevery_text

[/code]2)用sub实现翻页功能

foriinrange(2,total_page+1):

new_link=re.sub('pageNum=\d+','pageNum=%d'%i,old_url,re.S)

printnew_link

[/code]完整代码

importre

a='xzx23'

#.:匹配任意字符，换行符\n除外

#点.是一个占位符，一个.代表一个符号

b=re.findall('x.',a)

print(".:匹配任意字符，换行符\\n除外:",b)

#*:匹配前一个字符0次或无限次

#依次匹配字符，有则显示，无则显示''(空)。

c=re.findall('x*',a)

print("*:匹配前一个字符0次或无限次:",c)

#问号?

#?:匹配前一个字符0次或1次

#单独与*一样，前面附加其他的符号将做非贪心限制

d=re.findall('x?',a)

print("?:匹配前一个字符0次或1次:",d)

#贪心.*

#只要满足条件全部显示，贪心算法

secret_code='ghkj08hs68xxIxxa14kgj4w314exxlovexxbvk14rgjhxxyouxxfj4286ykjhag2'

e=re.findall('xx.*xx',secret_code)

print("贪心.*:",e)

#非贪心.*?

secret_code='ghkj08hs68xxIxxa14kgj4w314exxlovexxbvk14rgjhxxyouxxfj4286ykjhag2'

f=re.findall('xx.*?xx',secret_code)

print("非贪心.*?:",f)

#():括号内的数据作为结果返回

#()包围所需要的内容，括号内的内容作为结果返回，不需要的内容放在括号外面

secret_code='ghkj08hs68xxIxxa14kgj4w314exxlovexxbvk14rgjhxxyouxxfj4286ykjhag2'

g=re.findall('xx(.*?)xx',secret_code)

print("非贪心.*?:",g)

#sub将符合条件的()内内容提换

#sub：替换符合规律的内容，返回替换后的值

s='123abcssfasdfas123'

output=re.sub('123(.*?)123','123789123',s)

print('sub将符合条件的()内内容提换:',output)

#re.S让.匹配所有行，包括了换行符（以\n的形式出现）

#search找到一个后返回，不继续，大大提高效率

#findall遍历全部，找到尽可能多的项

s2='''ghkj08hs68xxIxx123xxlove

xxbvk14rgjhxxfj4286ykjhag2'''

b=re.search('xx(.*?)xx(.*?)xx',s2,re.S)

print('search找到一个后返回，不继续，大大提高效率:',b)

#输出

#<_sre.SRE_Match

#object;

#span=(10,20),match='xxIxx123xx'>

#group是按括号顺序匹配

b=re.search('xx(.*?)xx(.*?)xx',s2,re.S).group(1)

print('search找到一个后返回，不继续，大大提高效率:',b)

#.group(3)报错

#Traceback(mostrecentcalllast):

#File"D:/WorkSpace/python/PycharmProjects/爬虫/代码/Python-master/ReDemo.py",line61,in<module>

#b=re.search('xx(.*?)xx(.*?)xx',s2,re.S).group(3)

#IndexError:nosuchgroup

#每一个匹配项为第一级列表，括号为二级列表

s2='''ghkj08hs68xxIxx123xxlovexxbvk14rgjhxxfj4286ykjhag2'''

f2=re.findall('xx(.*?)xx123xx(.*?)xx',s2,re.S)

print('每一个匹配项为第一级列表，括号为二级列表:',f2[0][1])

[/code]

参考来源：http://code.ziqiangxuetang.com/python/python-reg-expressions.html参考来源：http://blog.csdn.net/SkyeyesXY/article/details/50837984