正则表达式

1.使用方法¶

python

Python

import re

#compile函数，生成一个Pattern对象
pattern = re.compile(patternstr, flags = 0)
#match函数，从头开始匹配一个结果，返回re.Match对象或None
matchobj = re.match(patternstr, string, flags = 0)
matchobj = pattern.match(string, pos = 0, endpos = len(string)) #指定位置匹配，左闭右开
#search函数，任意位置匹配顺序第一个结果，返回re.Match对象或None
searchobj = re.search(patternstr, string, flags = 0)
matchobj = pattern.search(string, pos = 0, endpos = len(string)) #指定位置匹配，左闭右开
#findall函数，任意位置匹配全部结果，返回字符串（元组）的列表或空列表
findallres = re.findall(patternstr, string, flags = 0)
findallres = pattern.findall(string, pos = 0, endpos = len(string)) #指定位置匹配，左闭右开
#finditer函数，任意位置匹配全部结果，返回re.Match对象的迭代器
objiter = re.finditer(patternstr, string, flags = 0)
objiter = pattern.finditer(string, pos = 0, endpos = len(string)) #指定位置匹配，左闭右开
#sub函数，匹配并用repl替换，repl可以是字符串或函数，count是最大替换次数，返回字符串
newstr = re.sub(pattern, repl, string, count = 0, flags = 0)
newstr = pattern.sub(repl, string, count = 0)
#subn函数，用法与sub函数相同，以元组的方式返回字符串与替换的次数
newstrn = re.subn(pattern, repl, string, count = 0, flags = 0)
newstrn = pattern.subn(repl, string, count = 0)
#split函数，分割字符串（删去匹配到的部分），maxsplit是最大分割次数，返回字符串列表
strlist = re.split(pattern, string, maxsplit = 0, flags = 0)
strlist = pattern.split(string, maxsplit = 0)

#常见flags
re.I 忽略匹配时的大小写
re.M 多行匹配，影响 '^' 和 '$'
re.S '.' 默认不匹配换行，使 '.' 匹配包括换行在内的所有字符
re.U 根据Unicode字符集解析字符。这个标志影响 '\w', '\W', '\b', '\B'

#re.Match对象的相关操作
matchobj.group(num = 0) #返回匹配到的整个字串或分组
matchobj.span(num = 0) #返回匹配到的整个字串或分组的位置
matchobj.groups() #以元组形式返回匹配到的分组
matchobj.groupdict() #以字典形式返回匹配到的分组

Python

string = 'ci putao bu tu putao pi'
pattern = re.compile(r'\w* putao \w*')
matchobj = pattern.match(string)
    [in1]:matchobj.group()
    [out1]:'ci putao bu'
searchobj = pattern.search(string,5)
    [in2]:searchobj.group()
    [out2]:'tu putao pi'
findallres = pattern.findall(string)
    [in3]:findallres
    [out3]:['ci putao bu', 'tu putao pi']
newstr = pattern.sub('lalala',string)
    [in4]:newstr
    [out4]:'lalala lalala'
newstrn = pattern.subn('lalala',string)
    [in5]:newstrn
    [out5]:('lalala lalala',2)

Python

string = 'ci putao bu tu putao pi pi'
pattern = re.compile(r'(\w*) putao (?:\w*) (?P<part3>\w*)') 
  #(?:pattern)不会被储存  (?P<key>pattern)py特有字典记录分组的值
matchobj = pattern.match(string)
    [in1]:matchobj.group()
    [out1]:'ci putao bu tu'
    [in2]:matchobj.group(1)
    [out2]:'ci'
    [in3]:matchobj.group(2)
    [out3]:'tu'
    [in4]:matchobj.span(0)
    [out4]:(0, 14) #左闭右开
    [in5]:matchobj.groups()
    [out5]:('ci', 'tu')
    [in6]:matchobj.groupdict()
    [out6]:{'part3': 'tu'}
findallres = pattern.findall(string)
    [in7]:findallres
    [out7]:[('ci', 'tu'), ('', 'pi')] #顺序，贪婪，不重叠，存在分组时只会返回分组

Python

string = 'ci putao bu, tu putao pi pi.'
pattern = re.compile(r'\W+') 
[in1]:pattern.split(string)
[out1]:['ci', 'putao', 'bu', 'tu', 'putao', 'pi', 'pi', '']

2.普通字符¶

HTML

regular
<!--匹配对象-->
regular

<!--匹配时会按照顺序进行相互不重叠的匹配-->
对于字符串
123456
[0-9]{2}将会匹配到12,34,56
[0-9]{3,4}将会匹配到1234 (贪婪匹配)
[0-9]{3,4}?将会匹配到123,456 (非贪婪匹配)

3.元字符（部分）¶

字符	描述
`\`	转义字符
`^`	匹配输入字符串的开始位置。如果设置了 RegExp 对象的 Multiline 属性，`^`也匹配 `\n`或 `\r` 之后的位置。
`$`	匹配输入字符串的结束位置。如果设置了 RegExp 对象的 Multiline 属性，`^` 也匹配 `\n`或`\r`之后的位置。
`.`	匹配除换行符之外的任何单个字符
`x\|y`	代表“或”。`x\|yz`会匹配`x`或`yz`，而`(x\|y)z`匹配`xz`或`yz`。
`\b`	代表单词边界。`x\b`会匹配 `yyyyx zzzz` 中的`x`，但不会匹配`yyxyy zzzz` 中的`x`。
`\B`	代表非单词边界。`x\B`会匹配 `yyxyy zzzz` 中的`x`，但不会匹配`yyyyx zzzz` 中的`x`。
`\d`	代表数字。即`[0-9]`
`\D`	代表非数字。即`[^0-9]`
`\s`	匹配任何空白字符。包括空格、制表符、换页符等等。等价于`[ \f\n\r\t\v]`。
`\S`	匹配任何非空白字符。等价于`[^ \f\n\r\t\v]`。
`\w`	匹配包括下划线的任何单词字符。等价于`[A-Za-z0-9_]`。
`\W`	匹配任何非单词字符。等价于`[^A-Za-z0-9_]`。
`\f`	换页符
`\n`	换行符
`\r`	回车符
`\t`	水平制表符
`\v`	垂直制表符

4.限定符与非贪婪匹配（属于元字符）¶

HTML

<!--匹配'+'前一个子表达式1次或多次-->
regular+
<!--匹配对象-->
regular|regularrrr|...

regu(lar)+ 
<!--匹配对象-->
regular|regularlarlar|...

<!--将'?'紧跟在'+'或'*'等限定符后，代表非贪婪匹配-->
对于字符串
<a></a>
<.+>将会匹配到<a></a>
<.+?>将会匹配到<a>和</a>

HTML

<!--匹配'*'前一个子表达式0次、1次或多次-->
regular*
<!--匹配对象-->
regula|regular|regularrrr|...

HTML

<!--匹配'?'前一个子表达式0次或1次-->
regular?
<!--匹配对象-->
regula|regular

HTML

<!--匹配'{n}'前一个子表达式n次-->
regular{3}
<!--匹配对象-->
regularrr

HTML

<!--匹配'{n,}'前一个子表达式n次及以上次-->
regular{3,}
<!--匹配对象-->
regularrr|regularrrr|...

HTML

<!--匹配'{n,m}'前一个子表达式最少n次且最多m次-->
regular{3,5}
<!--匹配对象-->
regularrr|regularrrr|regularrrrr

5.字符集合（属于元字符）¶

HTML

<!--[ABC]匹配中括号中任意一个字符-->
[aeiou]
<!--匹配对象-->
a|e|i|o|u

[a-z]
<!--匹配对象-->
所有小写字母

[A-Z]
<!--匹配对象-->
所有大写字母

[0-9]
<!--匹配对象-->
所有数字

[a-zA-Z]
<!--匹配对象-->
所有英文字母

[^aeiouA-Z]
<!--匹配对象-->
字符的补集，除了小写aeiou和所有大写字母外的所有字符

6.分组（属于元字符）¶

字符	描述
`(pattern)`	匹配 pattern 并获取这一匹配。所获取的匹配可以从产生的 Matches 集合得到，在VBScript 中使用 SubMatches 集合，在JScript 中则使用 `$0...$9` 属性。
`(?:pattern)`	匹配 pattern 但不获取匹配结果。也就是说这是一个非获取匹配，不进行存储供以后使用。
`(?=pattern)`	正向先行断言，从该位置向右开始必须能够匹配pattern。只是一个需要满足的条件，并不会获取。
`(?!pattern)`	反向先行断言，从该位置向右开始必须不能匹配pattern。只是一个需要满足的条件，并不会获取。
`(?<=pattern)`	正向后行断言，从该位置向左开始必须能够匹配pattern。只是一个需要满足的条件，并不会获取。
`(?<!pattern)`	反向后行断言，从该位置向左开始必须不能匹配pattern。只是一个需要满足的条件，并不会获取。

回溯引用（与之前分组中匹配相同的数据）

HTML

(\w)(\w)\2\1
<!--匹配对象-->
abba|cddc|...

<(\w+)>.*?</\1>
<!--匹配对象-->
<div>aaa</div>|...
<!--不会匹配对象-->
<div>aaa</a>|...

正向先行断言

HTML

ab(?=c)
<!--匹配对象-->
abc <!--仅获取ab-->

反向先行断言

HTML

ab(?!c)
<!--匹配对象-->
abd|abf|... <!--仅获取ab-->

正向后行断言

HTML

<!--以下正则表达式在html中语法错误，故注释
(?<=c)ab
-->
<!--匹配对象-->
cab <!--仅获取ab-->

反向后行断言

HTML

(?<!c)ab
<!--匹配对象-->
dab|fab|... <!--仅获取ab-->

7.应用¶

匹配质数个x

HTML

^(?!(xx+)\1+$)
<!--匹配对象-->
xx|xxx|xxxxx|...
<!--不会匹配对象-->
xxxx|xxxxxx|...

分析：满足断言则代表，该数可以表示为2及以上数字的2及以上倍，即该数为合数。