Python中的正则表达式-re模块

Posted 2020-09-28

有时候我们需要模糊查找我们需要的字符串等值，这个时候需要用到正则表达式。

正则表达式的使用，在python中需要引入re包

import re

1、首先了解下正则表达式的常用语法

——单个字符

 

.	任意的一个字符
a|b	字符a或字符b
[afg]	a或者f或者g的一个字符
[0-4]	0-4范围内的一个字符
[a-f]	a-f范围内的一个字符
[^a]	不是a的一个字符
\s	一个空格
\S	一个非空格
\d	[0-9]，即0-9的任意字符
\D	[^0-9]，即非0-9的任意字符
\w	[0-9a-zA-Z]
\W	[^0-9a-zA-Z]
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如，“er\b”可以匹配“never”中的“er”，但不能匹配“verb”中的“er”
\B	匹配非单词边界。“er\B”能匹配“verb”中的“er”，但不能匹配“never”中的“er”

 

——重复

*	重复>=0次
+	重复>=1次
？	重复0次或是1次
{m}	重复m次，如[01]{2}匹配字符串00或11或01或10
{m,n}	重复m-n次，如a{1,3}匹配字符串a或aa或aaa

——位置

^	字符串的起始位置
$	字符串的结尾位置

——返回控制

对搜索的结果进行进一步精简信息，可以使用小括号扩住对应的正则表达式。如

m = re.search("output_(\d{4}).*(\d{4})", "output_1986a.txt1233")

其中字符串匹配两个(\d{4})，最后可以输出1986和1233两个。分别为m.group(1)和m.group(2)

search()方法是在整个字符串中找，下面匹配了两组字符串，即两个小括号里面的内容，所以如果写match.group(3)就是报错，不存在该组

。如果给分组添加别名的话，就可以用到groupdict()，使用方法如下

>>> match = re.search(r‘(?P<first>\bt\w+)\W+(?P<second>\w+)‘, ‘This is test for python group‘) >>> print match <_sre.SRE_Match object at 0x23f6250> >>> print match.group() test for >>> print match.group(0) test for >>> print match.group(1) test >>> print match.group(2) for >>> print match.groupdict() {‘second‘: ‘for‘, ‘first‘: ‘test‘} >>> print match.groupdict()[‘first‘] test >>> print match.groupdict()[‘second‘] for

2、re中常用的方法

python通过re模块提供对正则表达式的支持，使用re模块一般是先将正则表达式的字符串形式编译成Pattern对象，然后用Pattern对象来处理文本得到一个匹配的结果，也就是一个Match对象，最后通过Match得到我们的信息并进行操作

1）compile方法

>>> help(re.compile) Help on function compile in module re:   compile(pattern, flags=0)     Compile a regular expression pattern, returning a pattern object.

上面可以看到compile返回一个pattern对象。其中第二个参数flags是匹配模式，可以使用按位或“|”表示同时生效，也可以在正则表达式字符串中指定。pattern对象是不能直接实例化的，只能通过compile方法得到。匹配模式：

1).re.I(re.IGNORECASE): 忽略大小写 2).re.M(MULTILINE): 多行模式，改变‘^‘和‘$‘的行为 3).re.S(DOTALL): 点任意匹配模式，改变‘.‘的行为 4).re.L(LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定 5).re.U(UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性 6).re.X(VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释

如下代码：

import re pattern = re.compile(r‘re‘) pattern.match(‘This is re module of python‘) re.compile(r‘re‘, ‘This is re module of python‘) # 以上两种方式是一样的 # 以下两种方式是一样的 pattern1 = re.compile(r"""\d + #整数部分 \. #小数点 \d * #小数部分""", re.X) pattern2 = re.compile(r‘\d+\.\d*‘)

2）match方法

>>> help(re.match) Help on function match in module re:   match(pattern, string, flags=0)     Try to apply the pattern at the start of the string, returning     a match object, or None if no match was found.

match方法是对字符串的开头进行匹配。如果匹配到则返回一个match对象；如果匹配失败，则返回None。这个flags是编译pattern时指定的模式。group是Match对象的方法，表示得到的某个组的匹配。如果使用分组来查找字符串的各个部分，可以通过group得到每个组匹配到的字符串。

>>> match = re.match(r‘This‘, ‘This is re module of python‘) >>> print match <_sre.SRE_Match object at 0x0000000002C26168> >>> print match.group() This >>> match = re.match(r‘python‘, ‘This is re module of python‘) >>> print match None

3）search方法

>>> help(re.search) Help on function search in module re:   search(pattern, string, flags=0)     Scan through string looking for a match to the pattern, returning     a match object, or None if no match was found.

search()方法是在整个字符串中找，而match只是在字符串的开头找，上面匹配了两组字符串，即两个小括号里面的内容，所以如果写match.group(3)就是报错，不存在该组。如果给分组添加别名的话，就可以用到groupdict()，使用方法如下

>>> match = re.search(r‘(?P<first>\bt\w+)\W+(?P<second>\w+)‘, ‘This is test for python group‘) >>> print match <_sre.SRE_Match object at 0x23f6250> >>> print match.group() test for >>> print match.group(0) test for >>> print match.group(1) test >>> print match.group(2) for >>> print match.groupdict() {‘second‘: ‘for‘, ‘first‘: ‘test‘} >>> print match.groupdict()[‘first‘] test >>> print match.groupdict()[‘second‘] for

4）split方法

>>> help(re.split) Help on function split in module re:   split(pattern, string, maxsplit=0, flags=0)     Split the source string by the occurrences of the pattern,     returning a list containing the resulting substrings.

按匹配到的字符串来分隔给定的字符串，然后返回一个列表，maxsplit参数为最大的分隔次数。

>>> results = re.split(r‘\d+‘, ‘fasdf12fasdf4fasf1fasdf123‘) >>> type(results) <type ‘list‘> >>> print results [‘fasdf‘, ‘fasdf‘, ‘fasf‘, ‘fasdf‘, ‘‘] >>> results = re.split(r‘-‘, ‘2013-11-12‘) >>> print results [‘2013‘, ‘11‘, ‘12‘]

5）findall方法

>>> help(re.findall) Help on function findall in module re:   findall(pattern, string, flags=0)     Return a list of all non-overlapping matches in the string.         If one or more groups are present in the pattern, return a     list of groups; this will be a list of tuples if the pattern     has more than one group.         Empty matches are included in the result.

findall方法返回一个列表，里面方的是所有匹配到的字符串。如果我们的正则表达式没有给他们分组，那么就是匹配到的字符串；如果进行了分组，那么就是以元组的方式放在列表中

>>> results = re.findall(r‘\bt\w+\W+\w+‘, ‘this is test for python findall‘) >>> results [‘this is‘, ‘test for‘] >>> results = re.findall(r‘(\bt\w+)\W+(\w+)‘, ‘this is test for python findall‘) >>> results [(‘this‘, ‘is‘), (‘test‘, ‘for‘)]

6）sub和subn方法

sub(pattern, repl, string, count=0) subn(pattern, repl, string, count=0)

sub方法：先通过正则表达式匹配string中的字符串，匹配到了再用repl来替换，count表示要替换的次数，不传参表示全部替换，返回的是替换过后的字符串。repl可以是一个字符串，也可以是一个方法，是方法的时候，必须有一个参数就是Match对象，必须返回一个用于替换的字符串。通过上面的代码可以看出，这个Match对象就是匹配到的Match对象，还记得match和search方法的返回值吧。如果要对匹配到的字符串做改变，用第二种方式会清晰一点

>>> print re.sub(r‘(\w+) (\w+)‘, r‘\2 \1‘, ‘i say, hello world!‘) say i, world hello!

subn方法和sub方法基本上是一样的，只是sub返回的是替换后的字符串，而subn返回的是一个元组，这个元组有两个元素，第一个是替换过后的字符串，第二个是number，也就是替换的次数，如果我们后面指定替换的次数后，那么这个number就和我们指定的count一样

>>> print re.subn(r‘(\w+) (\w+)‘, r‘\2 \1‘, ‘i say, hello world!‘) (‘say i, world hello!‘, 2) >>> print re.subn(r‘(\w+) (\w+)‘, r‘\2 \1‘, ‘i say, hello world!‘, count=1) (‘say i, hello world!‘, 1)