正则表达式、re模块

正则表达式

一说规则我已经知道你很晕了，现在就让我们先来看一些实际的应用。在线测试工具 http://tool.chinaz.com/regex/

正则表达式是用来匹配字符串非常强大的工具，在其他编程语言中同样有正则表达式的概念。就其本质而言，正则表达式（或 RE）是一种小型的、高度专业化的编程语言，（在Python中）它内嵌在Python中，并通过 re 模块实现。正则表达式模式被编译成一系列的字节码，然后由用 C 编写的匹配引擎执行。

元字符	匹配内容
.	匹配除换行符以外的任意字符
\w	匹配字母或数字或下划线
\s	匹配任意的空白符
\d	匹配数字
\n	匹配一个换行符
\t	匹配一个制表符
\b	匹配一个单词的结尾
^	匹配字符串的开始
$	匹配字符串的结尾
\W	匹配非字母或数字或下划线
\D	匹配非数字
\S	匹配非空白符
a|b	匹配字符a或字符b
()	匹配括号内的表达式，也表示一个组
[...]	匹配字符组中的字符
[^...]	匹配除了字符组中字符的所有字符

*	"*" 匹配前一个字符0次或者无限次
+	"+" 匹配前一个字符1次或者无限次
?	"?" 匹配一个字符0次或者1次
{m} {m,n}	{m} {m,n} 匹配前一个字符m次或者m到n次
*? +? ??	*? +? ?? 匹配模式变为非贪婪（尽可能少匹配字符串）

^	"^" 匹配字符串开头,多行模式中匹配每一行的开头
$	"$" 匹配字符串结尾,多行模式中匹配每一行的末尾
\A	\A 仅匹配字符串开头
\Z	\Z 仅匹配字符串结尾
\b	\b 匹配一个单词边界，也就是指单词和空格间的位置

|	"|" 匹配左右任意一个表达式
ab	(ab) 括号中表达式作为一个分组
\<number>	\<number> 引用编号为num的分组匹配到的字符串
(?P<key>vlaue)	(?P<key>vlaue) 匹配到一个字典，去vlaue也可做别名
(?P=name)	(?P=name) 引用别名为name的分组匹配字符串

模块方法介绍：

match	从头匹配
search	匹配整个字符串，直到找到一个匹配
findall	找到匹配，返回所有匹配部分的列表
finditer	返回一个迭代器
sub	将字符串中匹配正则表达式的部分替换为其他值
split	根据匹配分割字符串，返回分割字符串组成的列表

group()	返回被 RE 匹配的字符串
groups()	返回一个包含正则表达式中所有小组字符串的元组，从 1 到所含的小组号
groupdict()	返回(?P<key>vlace)定义的字典
start()	返回匹配开始的位置
end()	返回匹配结束的位置
span()	返回一个元组包含匹配 (开始,结束) 的索引位置

re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware）匹配
re.M	多行匹配，影响 ^ 和 $
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X	注释，会影响空格（无效了）

转义符 \

在正则表达式中，有很多有特殊意义的是元字符，比如\d和\s等，如果要在正则中匹配正常的"\d"而不是"数字"就需要对"\"进行转义，变成'\\'。

在python中，无论是正则表达式，还是待匹配的内容，都是以字符串的形式出现的，在字符串中\也有特殊的含义，本身还需要转义。所以如果匹配一次"\d",字符串中要写成'\\d'，那么正则里就要写成"\\\\d",这样就太麻烦了。这个时候我们就用到了r'\d'这个概念，此时的正则是r'\\d'就可以了。

正则	待匹配字符	匹配 结果	说明
\d	\d	False	因为在正则表达式中\是有特殊意义的字符，所以要匹配\d本身，用表达式\d无法匹配
\\d	\d	True	转义\之后变成\\，即可匹配
"\\\\d"	'\\d'	True	如果在python中，字符串中的'\'也需要转义，所以每一个字符串'\'又需要转义一次
r'\\d'	r'\d'	True	在字符串之前加r，让整个字符串不转义

import re

ret = re.findall('a', 'eva egon yuan')  # 返回所有满足匹配条件的结果,放在列表里
print(ret) #结果 : ['a', 'a']

ret = re.search('a', 'eva egon yuan').group()
print(ret) #结果 : 'a'
# 函数会在字符串内查找模式匹配,只到找到第一个匹配然后返回一个包含匹配信息的对象,该对象可以
# 通过调用group()方法得到匹配的字符串,如果字符串没有匹配，则返回None。

ret = re.match('a', 'abc').group()  # 同search,不过尽在字符串开始处进行匹配
print(ret)
#结果 : 'a'

ret = re.split('[ab]', 'abcd')  # 先按'a'分割得到''和'bcd',在对''和'bcd'分别按'b'分割
print(ret)  # ['', '', 'cd']

ret = re.sub('\d', 'H', 'eva3egon4yuan4', 1)#将数字替换成'H'，参数1表示只替换1个
print(ret) #evaHegon4yuan4

ret = re.subn('\d', 'H', 'eva3egon4yuan4')#将数字替换成'H'，返回元组(替换的结果,替换了多少次)
print(ret)

obj = re.compile('\d{3}')  #将正则表达式编译成为一个 正则表达式对象，规则要匹配的是3个数字
ret = obj.search('abc123eeee') #正则表达式对象调用search，参数为待匹配的字符串
print(ret.group())  #结果 ： 123

import re
ret = re.finditer('\d', 'ds3sy4784a')   #finditer返回一个存放匹配结果的迭代器
print(ret)  # <callable_iterator object at 0x10195f940>
print(next(ret).group())  #查看第一个结果
print(next(ret).group())  #查看第二个结果
print([i.group() for i in ret])  #查看剩余的左右结果　

注意：

1 findall的优先级查询：

import re

ret = re.findall('www.(baidu|oldboy).com', 'www.oldboy.com')
print(ret)  # ['oldboy']     这是因为findall会优先把匹配结果组里内容返回,如果想要匹配结果,取消权限即可

ret = re.findall('www.(?:baidu|oldboy).com', 'www.oldboy.com')
print(ret)  # ['www.oldboy.com']

　2 split的优先级查询：

ret=re.split("\d+","eva3egon4yuan")
print(ret) #结果 ： ['eva', 'egon', 'yuan']

ret=re.split("(\d+)","eva3egon4yuan")
print(ret) #结果 ： ['eva', '3', 'egon', '4', 'yuan']

#在匹配部分加上（）之后所切出的结果是不同的，
#没有（）的没有保留所匹配的项，但是有（）的却能够保留了匹配的项，
#这个在某些需要保留匹配部分的使用过程是非常重要的。　　

注意：贪婪匹配(.* |  .*?)

#.*默认为贪婪匹配
print(re.findall('a.*b','a1b22222222b')) #['a1b22222222b']

#.*?为非贪婪匹配：推荐使用
print(re.findall('a.*?b','a1b22222222b')) #['a1b']　　

注意：（分组）：   (.*?)显示匹配的整体  |  （其他）只显示组了的东西

#():分组
print(re.findall('ab+','ababab123')) #['ab', 'ab', 'ab']
print(re.findall('(ab)+123','ababab123')) #['ab']，匹配到末尾的ab123中的ab
print(re.findall('(?:ab)+123','ababab123')) #findall的结果不是匹配的全部内容，而是组内的内容,?:可以让结果为匹配的全部内容
print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击</a>'))#['http://www.baidu.com']
print(re.findall('href="(?:.*?)"','<a href="http://www.baidu.com">点击</a>'))#['href="http://www.baidu.com"']　　

注意：取消被匹配的特殊意义：

#rawstring：
# print(re.findall(r'a\\c','a\c a1c aBc')) #a\\c->a\c

　所有的：　

 import re

 # print(re.findall('\w','egon 123 + _ - *'))
 # print(re.findall('\W','egon 123 + _ - *'))
 # print(re.findall('\s','ego\tn 12\n3 + _ - *'))
 # print(re.findall('\S','ego\tn 12\n3 + _ - *'))
 # print(re.findall('\d','ego\tn 12\n3 + _ - *'))
 # print(re.findall('\D','ego\tn 12\n3 + _ - *'))
 # print(re.findall('\n','ego\tn 12\n3 + _ - *'))
 # print(re.findall('\t','ego\tn 12\n3 + _ - *'))
 # print(re.findall('e','ego\tn 12\n3 +hello _ - *'))
 # print(re.findall('^e','ego\tn 12\n3 +hello _ - *'))
 # print(re.findall('o$','ego\tn 12\n3 +hello'))

 #重复：.|?|*|+|{m,n}|.*|.*?
 #.代表任意一个字符
 # print(re.findall('a.b','a1b a b a-b aaaaaab'))
                     #   a.b
 # print(re.findall('a.b','a1b a b a\nb a-b aaaaaab',re.DOTALL))
                     #   a.b

 #?:代表?号左边的字符出现0次或者1
 # print(re.findall('ab?','a ab abb abbbb a1b')) #['a','ab','ab','ab','a']
 #                       #                  ab?

 #*:代表*号左边的字符出现0次或者无穷次
 # print(re.findall('ab*','a ab abb abbbb a1b')) #['a','ab','abb','abbbb','a']
                       #                  ab*

 #+:代表+号左边的字符出现1次或者无穷次
 # print(re.findall('ab+','a ab abb abbbb a1b')) #['ab','abb','abbbb']
 #                       #                  ab+

 # {m,n}:代表左边的字符出现m次到n次
 # print(re.findall('ab{0,1}','a ab abb abbbb a1b')) #['ab','abb','abbbb']
 # print(re.findall('ab?','a ab abb abbbb a1b')) #['ab','abb','abbbb']

 # print(re.findall('ab{0,}','a ab abb abbbb a1b')) #['ab','abb','abbbb']
 # print(re.findall('ab*','a ab abb abbbb a1b')) #['ab','abb','abbbb']

 # print(re.findall('ab{1,}','a ab abb abbbb a1b')) #['ab','abb','abbbb']
 # print(re.findall('ab+','a ab abb abbbb a1b')) #['ab','abb','abbbb']

 # print(re.findall('ab{2,4}','a ab abb abbbb a1b')) #['abb', 'abbbb']

 #.*:贪婪匹配
 # print(re.findall('a.*b','xxxy123a123b456b'))
                         #        a.*b
 #.*?:非贪婪匹配
 # print(re.findall('a.*?b','xxxy123a123b456b'))

 #|:或者
 # print(re.findall('compan(y|iess)','too many companiess have gone bankrupt, and the next one is my company'))
 # print(re.findall('compan(?:y|iess)','too many companiess have gone bankrupt, and the next one is my company'))
                                  #                                                                         compan(y|iess)

 # print(re.findall('href="(.*?)"','<a href="http://www.baidu.com">点击我</a>'))

 #rawstring：
 # print(re.findall(r'a\\c','a\c a1c aBc')) #a\\c->a\c

 #[]:取中括号内任意的一个
 # print(re.findall('a[a-z]b','axb azb aAb a1b a-b a+b'))
 # print(re.findall('a[A-Z]b','axb azb aAb a1b a-b a+b'))
 # print(re.findall('a[a-zA-Z]b','axb azb aAb a1b a-b a+b'))
 # print(re.findall('a[0-9]b','axb azb aAb a1b a-b a+b'))
 # print(re.findall('a[-+*/]b','axb azb aAb a1b a-b a+b'))
 # print(re.findall('a[^-+*/]b','axb azb aAb a1b a-b a+b'))

 #re模块的其他方法
 #re.search :只匹配成功一次就返回
 # print(re.search('a[*]b','axb azb aAb a1b a-b a+b'))
 # print(re.search('a[0-9]b','axb azb aAb a1b a-b a2b a+b').group())

 # re.match:从开头取
 # print(re.match('a[0-9]b','axb azb aAb a1b a-b a2b a+b'))
 # print(re.match('a[0-9]b','a1b axb azb aAb a1b a-b a2b a+b').group())
 # print(re.search('^a[0-9]b','a1b axb azb aAb a1b a-b a2b a+b').group())

 # re.split
 # print(re.split(':','root:x:0:0::/root:/bin/bash',maxsplit=1))
 # 'root:x:0:0::/root:/bin/bash'.split(':')

 # re.sub
 # print(re.sub('root','admin','root:x:0:0::/root:/bin/bash',1))
 #了解
 # print(re.sub('^([a-z]+)([^a-z]+)(.*?)([^a-z]+)([a-z]+)$',r'\5\2\3\4\1','root:x:0:0::/root:/bin/bash'))

 # re.compile
 obj=re.compile('a\d{2}b')
 print(obj.findall('a12b a123b a12345b abbb'))
 print(obj.search('a12b a123b a12345b abbb').group())