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

时间：2021-10-05 04:02:50
有时候我们需要模糊查找我们需要的字符串等值，这个时候需要用到正则表达式。
正则表达式的使用，在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)
标签：

相关文章