\w 匹配字母数字及下划线
\W 匹配非字母数字及下划线
\s 匹配任意空白字符,等价于 [\t\n\r\f].
\S 匹配任意非空字符
\d 匹配任意数字,等价于 [0-9]
\D 匹配任意非数字
\A 匹配字符串开始
\Z 匹配字符串结束,如果是存在换行,只匹配到换行前的结束字符串
\z 匹配字符串结束
\G 匹配最后匹配完成的位置
\n 匹配一个换行符
\t 匹配一个制表符
^ 匹配字符串的开头
$ 匹配字符串的末尾。
. 匹配任意字符,除了换行符,当re.DOTALL标记被指定时,则可以匹配包括换行符的任意字符。
[...] 用来表示一组字符,单独列出:[amk] 匹配 'a','m'或'k'
[^...] 不在[]中的字符:[^abc] 匹配除了a,b,c之外的字符。
* 匹配0个或多个的表达式。
+ 匹配1个或多个的表达式。
? 匹配0个或1个由前面的正则表达式定义的片段,非贪婪方式
{n} 精确匹配n个前面表达式。
{n, m} 匹配 n 到 m 次由前面的正则表达式定义的片段,贪婪方式
a|b 匹配a或b
( ) 匹配括号内的表达式,也表示一个组
Python中使用
match()
从字符串的起始位置匹配正则表达式,如果匹配,就返回匹配成功的结果,如果不匹配,那就返回None。
我们调用match()方法,第一个参数传入了正则表达式,第二个参数传入了要匹配的字符串。
import re
content = 'Hello 123 4567 World_This is a Regex Demo'
print(len(content))
result = re.match('^Hello\s\d\d\d\s\d{4}\s\w{10}', content)
print(result)
print(result.group())
print(result.span())
运行结果:
41
<_sre.SRE_Match object; span=(0, 25), match='Hello 123 4567 World_This'>
Hello 123 4567 World_This
(0, 25)
在这里我们首先声明了一个字符串,包含英文字母、空白字符、数字等等内容,接下来我们写了一个正则表达式^Hello\s\d\d\d\s\d{4}\s\w{10}
来匹配这个长字符串。
开头的^
是匹配字符串的开头,也就是以Hello
开头,然后\s
匹配空白字符,用来匹配目标字符串的空格,\d
匹配数字,三个\d
匹配123
,然后再写一个\s
匹配空格,后面还有4567
,我们其实可以依然用四个\d
来匹配,但是这么写起来比较繁琐,所以在后面可以跟{4}
代表匹配前面的字符四次,也就是匹配四个数字,这样也可以完成匹配,然后后面再紧接一个空白字符,然后\w{10}
匹配10个字母及下划线,正则表达式到此为止就结束了,我们注意到其实并没有把目标字符串匹配完,不过这样依然可以进行匹配,只不过匹配结果短一点而已。
我们调用match()方法,第一个参数传入了正则表达式,第二个参数传入了要匹配的字符串。
打印输出一下结果,可以看到结果是SRE_Match对象,证明成功匹配,它有两个方法,group()方法可以输出匹配到的内容,结果是Hello 123 4567 World_This
,这恰好是我们正则表达式规则所匹配的内容,span()方法可以输出匹配的范围,结果是(0, 25)
,这个就是匹配到的结果字符串在原字符串中的位置范围。
()
实际上就是标记了一个子表达式的开始和结束位置,被标记的每个子表达式会依次对应每一个分组,我们可以调用group()方法传入分组的索引即可获取提取的结果。
通用匹配
.*
,.
可以匹配任意字符(除换行符),*
又代表匹配前面的字符无限次,所以它们组合在一起就可以匹配任意的字符了,
import re
content = 'Hello 123 4567 World_This is a Regex Demo'
result = re.match('^Hello.*Demo$', content)
print(result)
print(result.group())
print(result.span())
在这里我们将中间的部分直接省略,全部用.*
来代替,最后加一个结尾字符串就好了,运行结果如下:
<_sre.SRE_Match object; span=(0, 41), match='Hello 123 4567 World_This is a Regex Demo'>
Hello 123 4567 World_This is a Regex Demo
(0, 41)
可以看到group()方法输出了匹配的全部字符串,也就是说我们写的正则表达式匹配到了目标字符串的全部内容,span()方法输出(0, 41)
,是整个字符串的长度。
我们可以在使用.*
来简化正则表达式的书写。
贪婪匹配与非贪婪匹配
在使用上面的通用匹配.*
的时候可能我们有时候匹配到的并不是想要的结果,我们看下面的例子:
import re
content = 'Hello 1234567 World_This is a Regex Demo'
result = re.match('^He.*(\d+).*Demo$', content)
print(result)
print(result.group(1))
在这里我们依然是想获取中间的数字,所以中间我们依然写的是(\d+)
,数字两侧由于内容比较杂乱,所以两侧我们想省略来写,都写.*
,最后组成^He.*(\d+).*Demo$
,看样子并没有什么问题,我们看下运行结果:
<_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
7
奇怪的事情发生了,我们只得到了7这个数字,这是怎么回事?
这里就涉及一个贪婪匹配与非贪婪匹配的原因了,贪婪匹配下,.*
会匹配尽可能多的字符,我们的正则表达式中.*
后面是\d+
,也就是至少一个数字,并没有指定具体多少个数字,所以.*
就尽可能匹配多的字符,所以它把123456
也匹配了,给\d+
留下一个可满足条件的数字7
,所以\d+
得到的内容就只有数字7了。
非贪婪匹配的写法是 .*?
import re
content = 'Hello 1234567 World_This is a Regex Demo'
result = re.match('^He.*?(\d+).*Demo$', content)
print(result)
print(result.group(1))
在这里我们只是将第一个.*
改成了.*?
,转变为非贪婪匹配匹配。结果如下:
<_sre.SRE_Match object; span=(0, 40), match='Hello 1234567 World_This is a Regex Demo'>
1234567
很好,这下我们就可以成功获取1234567
了。原因可想而知,贪婪匹配是尽可能匹配多的字符,非贪婪匹配就是尽可能匹配少的字符,.*?
之后是\d+
用来匹配数字,当.*?
匹配到Hello
后面的空白字符的时候,再往后的字符就是数字了,而\d+
恰好可以匹配,那么这里.*?
就不再进行匹配,交给\d+
去匹配后面的数字。所以这样,.*?
匹配了尽可能少的字符,\d+
的结果就是1234567
了。
所以说,在做匹配的时候,字符串中间我们可以尽量使用非贪婪匹配来匹配,也就是用.*?
来代替.*
,以免出现匹配结果缺失的情况。
但这里注意,如果匹配的结果在字符串结尾,.*?
就有可能匹配不到任何内容了,因为它会匹配尽可能少的字符,例如:
import re
content = 'http://weibo.com/comment/kEraCN'
result1 = re.match('http.*?comment/(.*?)', content)
result2 = re.match('http.*?comment/(.*)', content)
print('result1', result1.group(1))
print('result2', result2.group(1))
运行结果:
result1
result2 kEraCN
search()
match()方法在我们在使用的时候需要考虑到开头的内容,所以在做匹配的时候并不那么方便,它适合来检测某个字符串是否符合某个正则表达式的规则。
所以在这里就有另外一个方法search(),它在匹配时会扫描整个字符串,然后返回第一个成功匹配的结果,也就是说,正则表达式可以是字符串的一部分,在匹配时,search()方法会依次扫描字符串,直到找到第一个符合规则的字符串,然后返回匹配内容,如果搜索完了还没有找到,那就返回None。
findall()
findall()方法会搜索整个字符串然后返回匹配正则表达式的所有内容。
https://blog.csdn.net/qq_878799579/article/details/72887612