Python正则表达式常⽤函数总结
本⽂实例总结了Python正则表达式常⽤函数。分享给⼤家供⼤家参考，具体如下：
re.match()
函数原型：
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.
函数作⽤：
re.match函数尝试从字符串的开头开始匹配⼀个模式，如果匹配成功，返回⼀个匹配成功的对象，否则返回None。
参数说明：
pattern：匹配的正则表达式
string：要匹配的字符串
flags：标志位，⽤于控制正则表达式的匹配⽅式。如是否区分⼤⼩写、是否多⾏匹配等。
我们可以使⽤group()或groups()匹配对象函数来获取匹配后的结果。
group()
group(...)
group([group1, ...]) -> str or tuple.
Return subgroup(s) of the match by indices or names.
For 0 returns the entire match.
获得⼀个或多个分组截获的字符串；指定多个参数时将以元组形式返回。group1可以使⽤编号也可以使⽤别名；编号0代表匹配的整个⼦串；默认返回group(0)；没有截获字符串的组返回None；截获了多次的组返回最后⼀次截获的⼦串。
groups()
groups(...)
groups([default=None]) -> tuple.
Return a tuple containing all the subgroups of the match, from 1.
The default argument is used for groups
that did not participate in the match
以元组形式返回全部分组截获的字符串。相当于调⽤group(1,2,…last)。没有截获字符串的组以默认值None代替。
实例
import re
line = "This is the last one"
res = re.match( r'(.*) is (.*?) .*', line, re.M|re.I)
if res:
print "up() : ", up()
print "up(1) : ", up(1)
print "up(2) : ", up(2)
print "ups() : ", ups()
else:
print "No match!!"
re.M|re.I：这两参数表⽰多⾏匹配|不区分⼤⼩写，同时⽣效。
细节实例：
>>> re.match(r'.*','.*g3jl\nok').group()
'.*g3jl'
.（点）表⽰除换⾏符以外的任意⼀个字符，*（星号）表⽰匹配前⾯⼀个字符0次1次或多次，这两联合起来使⽤表⽰匹配除换⾏符意外的任意多个字符，所以出现以上的结果。
1、
re.match(r'.*..', '..').group()
'..'
2、
>>> re.match(r'.*g.','.*g3jlok').group()
'.*g3'
3、
>>> re.match(r'.*...', '..').group()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
上⾯两例⼦为什么有结果呢？这是因为第⼀个例⼦.*..中的.*匹配了0次，后⾯的..匹配字符串中..，⽽第⼆个例⼦中的 .* 匹配了⼀次，匹配字符串中的 .*，g匹配了后⾯的g字符，最后⼀个.号匹配了。
为什么第三个例⼦没有匹配到结果呢？这是因为就算正则表达式中的 .* 匹配0次，后⾯的三个点也不能完全匹配原字符串中的两个点，所以匹配失败了。
从上⾯⼏个例⼦可以看出，只有当正则表达式中要匹配的字符数⼩于等于原字符串中的字符数，才能匹配出结果。并且 “.*” 在匹配的过程中会回溯，先匹配0次，如果整个表达式能匹配成功，再匹配⼀次，如果还是能匹配，那就匹配两次，这样⼀次下去，直到不能匹配成功时，返回最近⼀次匹配成功的结果，这就是”.*”的贪婪性。
匹配Python中的标识符：
>>> re.match(r'^[a-zA-Z|_][\w_]*','_1name1').group()
'_1name1'
>>> re.match(r'^[a-zA-Z|_][\w_]*','_name1').group()
'_name1'
>>> re.match(r'^[a-zA-Z|_][\w_]*','num').group()
'num'
>>> re.match(r'^[a-zA-Z|_][\w_]*','1num').group()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
re.search()
函数原型：
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.
函数作⽤：
扫描整个字符串并返回第⼀次成功的匹配对象，如果匹配失败，则返回None。
参数说明：
pattern：匹配的正则表达式
string：要匹配的字符串
flags：标志位，⽤于控制正则表达式的匹配⽅式。如是否区分⼤⼩写、是否多⾏匹配等。
跟re.match函数⼀样，使⽤group()和groups()⽅法来获取匹配后的结果。
>>> re.search(r'[abc]\*\d{2}','12a*23Gb*12ad').group()
'a*23'
从匹配结果看出，re.search返回了第⼀次匹配成功的结果'a*23'，如果尽可能多的匹配的话，还可以匹配后⾯的'b*12'。
re.match与re.search的区别
re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；⽽re.search匹配整个字符串，直到到⼀个匹配，否则也返回None。
>>> re.match(r'(.*)(are)',"Cats are smarter than dogs").group(2)
'are'
>>> re.search(r'(are)+',"Cats are smarter than dogs").group()
'are'
上⾯两个例⼦是等价的。
re.sub()
Python的re模块中提供了re.sub()函数⽤于替换字符串中的匹配项，如果没有匹配的项则字符串将没有匹配的返回。
函数原型：
sub(pattern, repl, string, count=0, flags=0)
Return the string obtained by replacing the leftmost
non-overlapping occurrences of the pattern in string by the
replacement repl.  repl can be either a string or a callable;
if a string, backslash escapes in it are processed.  If it is
a callable, it's passed the match object and must return
a replacement string to be used.
参数说明：
pattern：匹配的正则表达式
repl：⽤于替换的字符串
string：要被替换的字符串
count：替换的次数，如果为0表⽰替换所有匹配到的字串，如果是1表⽰替换1次等，该参数必须是⾮
负整数，默认为0。flags：标志位，⽤于控制正则表达式的匹配⽅式。如是否区分⼤⼩写、是否多⾏匹配等。
实例
将⼿机号的后4位替换成0
>>> re.sub('\d{4}$','0000','135********')
'135********'
将代码后⾯的注释信息去掉
>>> re.sub('#.*$','', 'num = 0 #a number')
'num = 0 '
re.split()
函数原型：
split(pattern, string, maxsplit=0, flags=0)
Split the source string by the occurrences of the pattern,
returning a list containing the resulting substrings.
函数作⽤：
分割字符串，将字符串⽤给定的正则表达式匹配的字符串进⾏分割，分割后返回结果list。
参数说明：
pattern：匹配的正则表达式
string：被分割的字符串
maxsplit：最⼤的分割次数
flags：标志位，⽤于控制正则表达式的匹配⽅式。如是否区分⼤⼩写、是否多⾏匹配等。
re.findall()
函数原型：
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.
函数的作⽤：
获取字符串中所有匹配的字符串，并以列表的形式返回。列表中的元素有如下⼏种情况：
当正则表达式中含有多个圆括号()时，列表的元素为多个字符串组成的元组，⽽且元组中字符串个数与括号对数相同，并且字符串排放顺序跟括号出现的顺序⼀致（⼀般看左括号'(‘就⾏），字符串内容与每个括号内的正则表达式想对应。
当正则表达式中只带有⼀个圆括号时，列表中的元素为字符串，并且该字符串的内容与括号中的正则
表达式相对应。（注意：列表中的字符串只是圆括号中的内容，不是整个正则表达式所匹配的内容。）
当正则表达式中没有圆括号时，列表中的字符串表⽰整个正则表达式匹配的内容。
参数说明：
pattern：匹配的正则表达式
string：被分割的字符串
flags：标志位，⽤于控制正则表达式的匹配⽅式。如是否区分⼤⼩写、是否多⾏匹配等。
实例：
1、匹配字符串中所有含有'oo'字符的单词
#正则表达式中没有括号
>>> re.findall(r'\w*oo\w*', 'woo this foo is too')
['woo', 'foo', 'too']
从结果可以看出，当正则表达式中没有圆括号时，列表中的字符串表⽰整个正则表达式匹配的内容
2、获取字符串中所有的数字字符串
#正则表达式中只有1个括号
>>> re.findall(r'.*?(\d+).*?','adsd12343.jl34d5645fd789')
['12343', '34', '5645', '789']
从上⾯结果可以看出，当正则表达式中只带有⼀个圆括号时，列表中的元素为字符串，并且该字符串的内容与括号中的正则表达式相对应。
3、提取字符串中所有的有效的域名地址
#正则表达式中有多个括号时
>>> add = 'www.edu//action=?asdfsd and other www.baidu//a=b'
>>> re.findall(r'((w{3}\.)(\w+\.)+(com|edu|cn|net))',add)
[('www.edu', 'www.', 'com.', 'edu'), ('www.baidu', 'www.', 'baidu.','com')]
从执⾏结果可以看出，正则表达式中有多个圆括号时，返回匹配成功的列表中的每⼀个元素都是由⼀次匹配成功后，正则表达式中所有括号中匹配的内容组成的元组。
re.finditer()
函数原型：
finditer(pattern, string, flags=0)
Return an iterator over all non-overlapping matches in the string.  For each match, the iterator
returns a match object.
Empty matches are included in the result.
函数作⽤：
跟re.findall()函数⼀样，匹配字符串中所有满⾜的字串，只是返回的是⼀个迭代器，⽽不是⼀个像findall函数那样存有所有结果的list，这个迭代器⾥⾯存的是每⼀个结果的⼀个匹配对象，这样可以节省空间，⼀般⽤在需要匹配⼤量的结果时，类似于range和xrange的区别。
参数说明：
pattern：匹配的正则表达式
string：被分割的字符串
flags：标志位，⽤于控制正则表达式的匹配⽅式。如是否区分⼤⼩写、是否多⾏匹配等。
如：匹配字符串中所有的数字字串
>>> for i in re.finditer(r'\d+','one12two34three56four') :
...  up(),
python正则表达式不包含...
12 34 56
start()
返回匹配的起始位置。如：
>>> re.search(r'\d+', 'asdf13df234').start()
注意，索引位置是从0开始计数的。
end()
返回匹配结束的下⼀个位置。如：
>>> re.search(r'\d+', 'asdf13df234').end()
span()
返回匹配的区间，左闭右开。如：
>>> re.search(r'\d+', 'asdf13df234').span()
(4, 6)
repile()
函数原型：
compile(pattern, flags=0)
Compile a regular expression pattern, returning a pattern object.
函数作⽤：
编译⼀个正则表达式语句，并返回编译后的正则表达式对象。
这样我们就可以将那些经常使⽤的正则表达式编译成正则表达式对象，可以提⾼⼀定的效率。如：⼀句话包含五个英⽂单词，长度不⼀定，⽤空格分割，请把五个单词匹配出来
>>> s = "this is  a python test"
>>> p = repile('\w+') #编译正则表达式，获得其对象
>>> res = p.findall(s)#⽤正则表达式对象去匹配内容
>>> print res
['this', 'is', 'a', 'python', 'test']
PS：这⾥再为⼤家提供2款⾮常⽅便的正则表达式⼯具供⼤家参考使⽤：
更多关于Python相关内容可查看本站专题：《》、《》、《》、《》、《》及《》
希望本⽂所述对⼤家Python程序设计有所帮助。

版权声明：本站内容均来自互联网，仅供演示用，请勿用于商业和其他非法用途。如果侵犯了您的权益请与我们联系QQ:729038198，我们将在24小时内删除。