正则表达式、re模块

时间：2024-05-25 12:33:56

正则表达式

一说规则我已经知道你很晕了，现在就让我们先来看一些实际的应用。在线测试工具 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())

相关文章