python，字符串正则，替换最后一个特定字符_百度知道
python，字符串正则，替换最后一个特定字符
;我想替换字符串结束为止的abc替换后为‘abcabcO’我用的命令是：a.replace('abc$'abcabcabc'o&#39比如,&#39：a=&#39
提问者采纳
p>在 python 中。所以你会看到,&pile(r&#39，'X''123;abc$&#39，而是字符串;re，可以试一试 python 中的 re 模块例如;replace_reg.replace 函数接受的第一个参数并不是正则表达式，运行print&)&)的结果是')print&.replace(&#39,&rereplace_reg&nbsp.sub(';想要达到你所说的效果!123'123X'的运行结果为!&#39：import&(abc)''123(abc)123'：'=&123abc'
提问者评价
其他类似问题
为您推荐：
python的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁python:正则表达式:替换字符串的问题_百度知道
python:正则表达式:替换字符串的问题
sub(a,我想把它里面的单个的数字(5和7)比如这个字符串 5+7+12+32;d)\d)&#39!&#92.compile(')s = &#39??&5+7+12+32';(;d(,s)结果却输出55+55+12+32不知道如何使用正则表达式实现 将类似这种字符串(只含有数字和加号)中单个数字替换为重复的数字,替换为55和77即 55+77+12+32事实上我这么写代码import rea = re!\print a.search(s).group()*2
想到了呢import rea = re,s?&lt.search(s);d)&#92?.sub(a;5+'while a.search(s).compile(&#39!&#92!\:
s =(.group()*2;d(;d)')s = &#39
提问者采纳
的正则没有错;$ARGV[0]=~s/(.;## 55+77+12+322;5+7+12+32&$ARGV[0]=~s/b(\eg..但这属于 Dynamic Regex Replacement 了python 我是不太会?& print $ARGV[0]'\d)&#92.，但你要用正则在查询替代的同时执行d)(;d)/$1 x 2&#47!&#92?. perl -le &#39，这个恐怕只有 perl 能够做到;$1 x 2/ &quot.1.;b/ print $ARGV[0]&#39. perl -le 'd)(&#92!\; &5+7+12+32&quot
提问者评价
perl我不太会呢 不过还是谢谢你了 用正则表达式写这种东西实在是有一些钻牛角尖了
其他类似问题
为您推荐：
其他3条回答
list2;+&#39:
list2.append(i+i)
else.split(&#39:
if len(i)==1;)list2 = []for i in list1a=&#39:
.append(i)for i in list2.;5+7+12+32&#39.;list1=a
s = '5+7+12+32'print '+'.join((len(i)==1 and i*2 or i) for i in s.split('+'))
用循环，找到一个，替换一下，再找下一个，再替换。一步到位的话，只能用替换函数了。python支持吗？
您可能关注的推广
正则表达式的相关知识
等待您来回答
下载知道APP
随时随地咨询
出门在外也不愁您好，欢迎光临崔庆才的博客，欢迎来稿，质量优秀我会主动与您联系并升级为专栏作者，让您的文章被更多人看到，谢谢。
> Python爬虫入门七之正则表达式
在前面我们已经搞定了怎样获取页面的内容，不过还差一步，这么多杂乱的代码夹杂文字我们怎样把它提取出来整理呢？下面就开始介绍一个十分强大的工具，正则表达式！
1.了解正则表达式
正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑。
正则表达式是用来匹配字符串非常强大的工具，在其他编程语言中同样有正则表达式的概念，Python同样不例外，利用了正则表达式，我们想要从返回的页面内容提取出我们想要的内容就易如反掌了。
正则表达式的大致匹配过程是：
1.依次拿出表达式和文本中的字符比较，
2.如果每一个字符都能匹配，则匹配成功；一旦有匹配不成功的字符则匹配失败。
3.如果表达式中有量词或边界，这个过程会稍微有一些不同。
2.正则表达式的语法规则
下面是Python中正则表达式的一些匹配规则，图片资料来自CSDN
3.正则表达式相关注解
（1）数量词的贪婪模式与非贪婪模式
正则表达式通常用于在文本中查找匹配的字符串。Python里数量词默认是贪婪的（在少数语言里也可能是默认非贪婪），总是尝试匹配尽可能多的字符；非贪婪的则相反，总是尝试匹配尽可能少的字符。例如：正则表达式”ab*”如果用于查找”abbbc”，将找到”abbb”。而如果使用非贪婪的数量词”ab*?”，将找到”a”。
注：我们一般使用非贪婪模式来提取。
（2）反斜杠问题
与大多数编程语言相同，正则表达式里使用”\”作为转义字符，这就可能造成反斜杠困扰。假如你需要匹配文本中的字符”\”，那么使用编程语言表示的正则表达式里将需要4个反斜杠”\\\\”：前两个和后两个分别用于在编程语言里转义成反斜杠，转换成两个反斜杠后再在正则表达式里转义成一个反斜杠。
Python里的原生字符串很好地解决了这个问题，这个例子中的正则表达式可以使用r”\\”表示。同样，匹配一个数字的”\\d”可以写成r”\d”。有了原生字符串，妈妈也不用担心是不是漏写了反斜杠，写出来的表达式也更直观勒。
4.Python Re模块
Python 自带了re模块，它提供了对正则表达式的支持。主要用到的方法列举如下
#返回pattern对象
re.compile(string[,flag])
#以下为匹配所用函数
re.match(pattern, string[, flags])
re.search(pattern, string[, flags])
re.split(pattern, string[, maxsplit])
re.findall(pattern, string[, flags])
re.finditer(pattern, string[, flags])
re.sub(pattern, repl, string[, count])
re.subn(pattern, repl, string[, count])
12345678910
#返回pattern对象re.compile(string[,flag])&&#以下为匹配所用函数re.match(pattern, string[, flags])re.search(pattern, string[, flags])re.split(pattern, string[, maxsplit])re.findall(pattern, string[, flags])re.finditer(pattern, string[, flags])re.sub(pattern, repl, string[, count])re.subn(pattern, repl, string[, count])
在介绍这几个方法之前，我们先来介绍一下pattern的概念，pattern可以理解为一个匹配模式，那么我们怎么获得这个匹配模式呢？很简单，我们需要利用re.compile方法就可以。例如
pattern = re.compile(r'hello')
pattern = re.compile(r'hello')
在参数中我们传入了原生字符串对象，通过compile方法编译生成一个pattern对象，然后我们利用这个对象来进行进一步的匹配。
另外大家可能注意到了另一个参数 flags，在这里解释一下这个参数的含义：
参数flag是匹配模式，取值可以使用按位或运算符’|’表示同时生效，比如re.I | re.M。
可选值有：
o re.I(全拼：IGNORECASE): 忽略大小写（括号内是完整写法，下同）
o re.M(全拼：MULTILINE): 多行模式，改变'^'和'$'的行为（参见上图）
o re.S(全拼：DOTALL): 点任意匹配模式，改变'.'的行为
o re.L(全拼：LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定
o re.U(全拼：UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性
o re.X(全拼：VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。
o re.I(全拼：IGNORECASE): 忽略大小写（括号内是完整写法，下同） o re.M(全拼：MULTILINE): 多行模式，改变'^'和'$'的行为（参见上图） o re.S(全拼：DOTALL): 点任意匹配模式，改变'.'的行为 o re.L(全拼：LOCALE): 使预定字符类 \w \W \b \B \s \S 取决于当前区域设定 o re.U(全拼：UNICODE): 使预定字符类 \w \W \b \B \s \S \d \D 取决于unicode定义的字符属性 o re.X(全拼：VERBOSE): 详细模式。这个模式下正则表达式可以是多行，忽略空白字符，并可以加入注释。
在刚才所说的另外几个方法例如 re.match 里我们就需要用到这个pattern了，下面我们一一介绍。
注：以下七个方法中的flags同样是代表匹配模式的意思，如果在pattern生成时已经指明了flags，那么在下面的方法中就不需要传入这个参数了。
（1）re.match(pattern, string[, flags])
这个方法将会从string（我们要匹配的字符串）的开头开始，尝试匹配pattern，一直向后匹配，如果遇到无法匹配的字符，立即返回None，如果匹配未结束已经到达string的末尾，也会返回None。两个结果均表示匹配失败，否则匹配pattern成功，同时匹配终止，不再对string向后匹配。下面我们通过一个例子理解一下
__author__ = 'CQC'
# -*- coding: utf-8 -*-
#导入re模块
# 将正则表达式编译成Pattern对象，注意hello前面的r的意思是“原生字符串”
pattern = re.compile(r'hello')
# 使用re.match匹配文本，获得匹配结果，无法匹配时将返回None
result1 = re.match(pattern,'hello')
result2 = re.match(pattern,'helloo CQC!')
result3 = re.match(pattern,'helo CQC!')
result4 = re.match(pattern,'hello CQC!')
#如果1匹配成功
if result1:
# 使用Match获得分组信息
print result1.group()
print '1匹配失败！'
#如果2匹配成功
if result2:
# 使用Match获得分组信息
print result2.group()
print '2匹配失败！'
#如果3匹配成功
if result3:
# 使用Match获得分组信息
print result3.group()
print '3匹配失败！'
#如果4匹配成功
if result4:
# 使用Match获得分组信息
print result4.group()
print '4匹配失败！'
1234567891011121314151617181920212223242526272829303132333435363738394041424344
__author__ = 'CQC'# -*- coding: utf-8 -*-&#导入re模块import re&# 将正则表达式编译成Pattern对象，注意hello前面的r的意思是“原生字符串”pattern = re.compile(r'hello')&# 使用re.match匹配文本，获得匹配结果，无法匹配时将返回Noneresult1 = re.match(pattern,'hello')result2 = re.match(pattern,'helloo CQC!')result3 = re.match(pattern,'helo CQC!')result4 = re.match(pattern,'hello CQC!')&#如果1匹配成功if result1:&&&&# 使用Match获得分组信息&&&&print result1.group()else:&&&&print '1匹配失败！'&&#如果2匹配成功if result2:&&&&# 使用Match获得分组信息&&&&print result2.group()else:&&&&print '2匹配失败！'&&#如果3匹配成功if result3:&&&&# 使用Match获得分组信息&&&&print result3.group()else:&&&&print '3匹配失败！'&#如果4匹配成功if result4:&&&&# 使用Match获得分组信息&&&&print result4.group()else:&&&&print '4匹配失败！'
3匹配失败！
hellohello3匹配失败！hello
1.第一个匹配，pattern正则表达式为’hello’，我们匹配的目标字符串string也为hello，从头至尾完全匹配，匹配成功。
2.第二个匹配，string为helloo CQC，从string头开始匹配pattern完全可以匹配，pattern匹配结束，同时匹配终止，后面的o CQC不再匹配，返回匹配成功的信息。
3.第三个匹配，string为helo CQC，从string头开始匹配pattern，发现到 ‘o’ 时无法完成匹配，匹配终止，返回None
4.第四个匹配，同第二个匹配原理，即使遇到了空格符也不会受影响。
我们还看到最后打印出了result.group()，这个是什么意思呢？下面我们说一下关于match对象的的属性和方法
Match对象是一次匹配的结果，包含了很多关于此次匹配的信息，可以使用Match提供的可读属性或方法来获取这些信息。
1.string: 匹配时使用的文本。
2.re: 匹配时使用的Pattern对象。
3.pos: 文本中正则表达式开始搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
4.endpos: 文本中正则表达式结束搜索的索引。值与Pattern.match()和Pattern.seach()方法的同名参数相同。
5.lastindex: 最后一个被捕获的分组在文本中的索引。如果没有被捕获的分组，将为None。
6.lastgroup: 最后一个被捕获的分组的别名。如果这个分组没有别名或者没有被捕获的分组，将为None。
1.group([group1, …]):
获得一个或多个分组截获的字符串；指定多个参数时将以元组形式返回。group1可以使用编号也可以使用别名；编号0代表整个匹配的子串；不填写参数时，返回group(0)；没有截获字符串的组返回None；截获了多次的组返回最后一次截获的子串。
2.groups([default]):
以元组形式返回全部分组截获的字符串。相当于调用group(1,2,…last)。default表示没有截获字符串的组以这个值替代，默认为None。
3.groupdict([default]):
返回以有别名的组的别名为键、以该组截获的子串为值的字典，没有别名的组不包含在内。default含义同上。
4.start([group]):
返回指定的组截获的子串在string中的起始索引（子串第一个字符的索引）。group默认值为0。
5.end([group]):
返回指定的组截获的子串在string中的结束索引（子串最后一个字符的索引+1）。group默认值为0。
6.span([group]):
返回(start(group), end(group))。
7.expand(template):
将匹配到的分组代入template中然后返回。template中可以使用\id或\g、\g引用分组，但不能使用编号0。\id与\g是等价的；但\10将被认为是第10个分组，如果你想表达\1之后是字符，只能使用\g0。
下面我们用一个例子来体会一下
# -*- coding: utf-8 -*-
#一个简单的match实例
# 匹配如下内容：单词+空格+单词+任意字符
m = re.match(r'(\w+) (\w+)(?P&sign&.*)', 'hello world!')
print "m.string:", m.string
print "m.re:", m.re
print "m.pos:", m.pos
print "m.endpos:", m.endpos
print "m.lastindex:", m.lastindex
print "m.lastgroup:", m.lastgroup
print "m.group():", m.group()
print "m.group(1,2):", m.group(1, 2)
print "m.groups():", m.groups()
print "m.groupdict():", m.groupdict()
print "m.start(2):", m.start(2)
print "m.end(2):", m.end(2)
print "m.span(2):", m.span(2)
print r"m.expand(r'\g \g\g'):", m.expand(r'\2 \1\3')
### output ###
# m.string: hello world!
# m.pos: 0
# m.endpos: 12
# m.lastindex: 3
# m.lastgroup: sign
# m.group(1,2): ('hello', 'world')
# m.groups(): ('hello', 'world', '!')
# m.groupdict(): {'sign': '!'}
# m.start(2): 6
# m.end(2): 11
# m.span(2): (6, 11)
# m.expand(r'\2 \1\3'): world hello!
123456789101112131415161718192021222324252627282930313233343536
# -*- coding: utf-8 -*-#一个简单的match实例&import re# 匹配如下内容：单词+空格+单词+任意字符m = re.match(r'(\w+) (\w+)(?P&sign&.*)', 'hello world!')&print "m.string:", m.stringprint "m.re:", m.reprint "m.pos:", m.posprint "m.endpos:", m.endposprint "m.lastindex:", m.lastindexprint "m.lastgroup:", m.lastgroupprint "m.group():", m.group()print "m.group(1,2):", m.group(1, 2)print "m.groups():", m.groups()print "m.groupdict():", m.groupdict()print "m.start(2):", m.start(2)print "m.end(2):", m.end(2)print "m.span(2):", m.span(2)print r"m.expand(r'\g \g\g'):", m.expand(r'\2 \1\3') ### output #### m.string: hello world!# m.re: # m.pos: 0# m.endpos: 12# m.lastindex: 3# m.lastgroup: sign# m.group(1,2): ('hello', 'world')# m.groups(): ('hello', 'world', '!')# m.groupdict(): {'sign': '!'}# m.start(2): 6# m.end(2): 11# m.span(2): (6, 11)# m.expand(r'\2 \1\3'): world hello!
（2）re.search(pattern, string[, flags])
search方法与match方法极其类似，区别在于match()函数只检测re是不是在string的开始位置匹配，search()会扫描整个string查找匹配，match（）只有在0位置匹配成功的话才有返回，如果不是开始位置匹配成功的话，match()就返回None。同样，search方法的返回对象同样match()返回对象的方法和属性。我们用一个例子感受一下
#导入re模块
# 将正则表达式编译成Pattern对象
pattern = re.compile(r'world')
# 使用search()查找匹配的子串，不存在能匹配的子串时将返回None
# 这个例子中使用match()无法成功匹配
match = re.search(pattern,'hello world!')
# 使用Match获得分组信息
print match.group()
### 输出 ###
12345678910111213
#导入re模块import re&# 将正则表达式编译成Pattern对象pattern = re.compile(r'world')# 使用search()查找匹配的子串，不存在能匹配的子串时将返回None# 这个例子中使用match()无法成功匹配match = re.search(pattern,'hello world!')if match:&&&&# 使用Match获得分组信息&&&&print match.group()### 输出 #### world
（3）re.split(pattern, string[, maxsplit])
按照能够匹配的子串将string分割后返回列表。maxsplit用于指定最大分割次数，不指定将全部分割。我们通过下面的例子感受一下。
pattern = re.compile(r'\d+')
print re.split(pattern,'one1two2three3four4')
### 输出 ###
# ['one', 'two', 'three', 'four', '']
import re&pattern = re.compile(r'\d+')print re.split(pattern,'one1two2three3four4')&### 输出 #### ['one', 'two', 'three', 'four', '']
（4）re.findall(pattern, string[, flags])
搜索string，以列表形式返回全部能匹配的子串。我们通过这个例子来感受一下
pattern = re.compile(r'\d+')
print re.findall(pattern,'one1two2three3four4')
### 输出 ###
# ['1', '2', '3', '4']
import re&pattern = re.compile(r'\d+')print re.findall(pattern,'one1two2three3four4')&### 输出 #### ['1', '2', '3', '4']
（5）re.finditer(pattern, string[, flags])
搜索string，返回一个顺序访问每一个匹配结果（Match对象）的迭代器。我们通过下面的例子来感受一下
pattern = re.compile(r'\d+')
for m in re.finditer(pattern,'one1two2three3four4'):
print m.group(),
### 输出 ###
import re&pattern = re.compile(r'\d+')for m in re.finditer(pattern,'one1two2three3four4'):&&&&print m.group(),&### 输出 #### 1 2 3 4
（6）re.sub(pattern, repl, string[, count])
使用repl替换string中每一个匹配的子串后返回替换后的字符串。
当repl是一个字符串时，可以使用\id或\g、\g引用分组，但不能使用编号0。
当repl是一个方法时，这个方法应当只接受一个参数（Match对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。
count用于指定最多替换次数，不指定时全部替换。
pattern = re.compile(r'(\w+) (\w+)')
s = 'i say, hello world!'
print re.sub(pattern,r'\2 \1', s)
def func(m):
return m.group(1).title() + ' ' + m.group(2).title()
print re.sub(pattern,func, s)
### output ###
# say i, world hello!
# I Say, Hello World!
123456789101112131415
import re&pattern = re.compile(r'(\w+) (\w+)')s = 'i say, hello world!'&print re.sub(pattern,r'\2 \1', s)&def func(m):&&&&return m.group(1).title() + ' ' + m.group(2).title()&print re.sub(pattern,func, s)&### output #### say i, world hello!# I Say, Hello World!
（7）re.subn(pattern, repl, string[, count])
返回 (sub(repl, string[, count]), 替换次数)。
pattern = re.compile(r'(\w+) (\w+)')
s = 'i say, hello world!'
print re.subn(pattern,r'\2 \1', s)
def func(m):
return m.group(1).title() + ' ' + m.group(2).title()
print re.subn(pattern,func, s)
### output ###
# ('say i, world hello!', 2)
# ('I Say, Hello World!', 2)
123456789101112131415
import re pattern = re.compile(r'(\w+) (\w+)')s = 'i say, hello world!' print re.subn(pattern,r'\2 \1', s) def func(m):&&&&return m.group(1).title() + ' ' + m.group(2).title() print re.subn(pattern,func, s) ### output #### ('say i, world hello!', 2)# ('I Say, Hello World!', 2)
5.Python Re模块的另一种使用方式
在上面我们介绍了7个工具方法，例如match，search等等，不过调用方式都是 re.match，re.search的方式，其实还有另外一种调用方式，可以通过pattern.match，pattern.search调用，这样调用便不用将pattern作为第一个参数传入了，大家想怎样调用皆可。
函数API列表
match(string[, pos[, endpos]]) | re.match(pattern, string[, flags])
search(string[, pos[, endpos]]) | re.search(pattern, string[, flags])
split(string[, maxsplit]) | re.split(pattern, string[, maxsplit])
findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags])
finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags])
sub(repl, string[, count]) | re.sub(pattern, repl, string[, count])
subn(repl, string[, count]) |re.sub(pattern, repl, string[, count])
match(string[, pos[, endpos]]) | re.match(pattern, string[, flags]) search(string[, pos[, endpos]]) | re.search(pattern, string[, flags]) split(string[, maxsplit]) | re.split(pattern, string[, maxsplit]) findall(string[, pos[, endpos]]) | re.findall(pattern, string[, flags]) finditer(string[, pos[, endpos]]) | re.finditer(pattern, string[, flags]) sub(repl, string[, count]) | re.sub(pattern, repl, string[, count]) subn(repl, string[, count]) |re.sub(pattern, repl, string[, count])
具体的调用方法不必详说了，原理都类似，只是参数的变化不同。小伙伴们尝试一下吧~
小伙伴们加油，即使这一节看得云里雾里的也没关系，接下来我们会通过一些实战例子来帮助大家熟练掌握正则表达式的。
参考文章：此文章部分内容出自
转载请注明： &
or分享 (0)
您的支持是博主写作最大的动力，如果您喜欢我的文章，感觉我的文章对您有帮助，请狠狠点击下面的Python 基础教程
Python正则表达式 正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。 re 模块使 Python 语言拥有全部的正则表达式功能。
compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。
re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。 本章节主要介绍Python中常用的正则表达式处理函数。 re.match函数 re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。 函数语法：
re.match(pattern, string, flags=0)
函数参数说明：
pattern匹配的正则表达式 string要匹配的字符串。 flags标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
匹配成功re.match方法返回一个匹配的对象，否则返回None。 我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
匹配对象方法描述
group(num=0)匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。 groups()返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
print(re.match('www', '').span())
# 在起始位置匹配
print(re.match('com', ''))
# 不在起始位置匹配
以上实例运行输出结果为：
#!/usr/bin/python
line = "Cats are smarter than dogs"
matchObj = re.match( r'(.*) are (.*?) .*', line, re.M|re.I)
if matchObj:
print "matchObj.group() : ", matchObj.group()
print "matchObj.group(1) : ", matchObj.group(1)
print "matchObj.group(2) : ", matchObj.group(2)
print "No match!!"
以上实例执行结果如下：
matchObj.group() :
Cats are smarter than dogs
matchObj.group(1) :
matchObj.group(2) :
re.search方法 re.search 扫描整个字符串并返回第一个成功的匹配。 函数语法：
re.search(pattern, string, flags=0)
函数参数说明：
pattern匹配的正则表达式 string要匹配的字符串。 flags标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。
匹配成功re.search方法返回一个匹配的对象，否则返回None。 我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
匹配对象方法描述
group(num=0)匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。 groups()返回一个包含所有小组字符串的元组，从 1 到 所含的小组号。
#!/usr/bin/python
# -*- coding: UTF-8 -*-
print(re.search('www', '').span())
# 在起始位置匹配
print(re.search('com', '').span())
# 不在起始位置匹配
以上实例运行输出结果为：
#!/usr/bin/python
line = "Cats are smarter than dogs";
searchObj = re.search( r'(.*) are (.*?) .*', line, re.M|re.I)
if searchObj:
print "searchObj.group() : ", searchObj.group()
print "searchObj.group(1) : ", searchObj.group(1)
print "searchObj.group(2) : ", searchObj.group(2)
print "Nothing found!!"
以上实例执行结果如下：
searchObj.group() :
Cats are smarter than dogs
searchObj.group(1) :
searchObj.group(2) :
re.match与re.search的区别 re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。 实例：
#!/usr/bin/python
line = "Cats are smarter than dogs";
matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
print "match --& matchObj.group() : ", matchObj.group()
print "No match!!"
matchObj = re.search( r'dogs', line, re.M|re.I)
if matchObj:
print "search --& matchObj.group() : ", matchObj.group()
print "No match!!"
以上实例运行结果如下：
No match!!
search --& matchObj.group() :
检索和替换 Python 的re模块提供了re.sub用于替换字符串中的匹配项。 语法：
re.sub(pattern, repl, string, max=0)
返回的字符串是在字符串中用 RE 最左边不重复的匹配来替换。如果模式没有发现，字符将被没有改变地返回。 可选参数 count 是模式匹配后替换的最大次数；count 必须是非负整数。缺省值是 0 表示替换所有的匹配。 实例：
#!/usr/bin/python
phone = " # This is Phone Number"
# Delete Python-style comments
num = re.sub(r'#.*$', "", phone)
print "Phone Num : ", num
# Remove anything other than digits
num = re.sub(r'\D', "", phone)
print "Phone Num : ", num
以上实例执行结果如下：
Phone Num :
Phone Num :
正则表达式修饰符 - 可选标志 正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：
修饰符描述 re.I使匹配对大小写不敏感 re.L做本地化识别（locale-aware）匹配 re.M多行匹配，影响 ^ 和 $ re.S使 . 匹配包括换行在内的所有字符 re.U根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B. re.X该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。
正则表达式模式 模式字符串使用特殊的语法来表示一个正则表达式： 字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。 多数字母和数字前加一个反斜杠时会拥有不同的含义。 标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。 反斜杠本身需要使用反斜杠转义。 由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r'/t'，等价于'//t')匹配相应的特殊字符。 下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。
模式描述 ^匹配字符串的开头 $匹配字符串的末尾。 .匹配任意字符，除了换行符，当re.DOTALL标记被指定时，则可以匹配包括换行符的任意字符。 [...]用来表示一组字符,单独列出：[amk] 匹配 'a'，'m'或'k' [^...]不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符。 re*匹配0个或多个的表达式。 re+匹配1个或多个的表达式。 re? 匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式 re{ n} re{ n,}精确匹配n个前面表达式。 re{ n, m}匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式 a| b匹配a或b (re)G匹配括号内的表达式，也表示一个组 (?imx)正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域。 (?-imx)正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域。 (?: re) 类似 (...), 但是不表示一个组 (?imx: re)在括号中使用i, m, 或 x 可选标志 (?-imx: re)在括号中不使用i, m, 或 x 可选标志 (?#...)注释. (?= re)前向肯定界定符。如果所含正则表达式，以 ... 表示，在当前位置成功匹配时成功，否则失败。但一旦所含表达式已经尝试，匹配引擎根本没有提高；模式的剩余部分还要尝试界定符的右边。 (?! re)前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功 (?& re)匹配的独立模式，省去回溯。 \w 匹配字母数字 \W匹配非字母数字 \s 匹配任意空白字符，等价于 [\t\n\r\f]. \S匹配任意非空字符 \d 匹配任意数字，等价于 [0-9]. \D匹配任意非数字 \A匹配字符串开始 \Z匹配字符串结束，如果是存在换行，只匹配到换行前的结束字符串。c \z匹配字符串结束 \G匹配最后匹配完成的位置。 \b匹配一个单词边界，也就是指单词和空格间的位置。例如， 'er\b' 可以匹配"never" 中的 'er'，但不能匹配 "verb" 中的 'er'。 \B匹配非单词边界。'er\B' 能匹配 "verb" 中的 'er'，但不能匹配 "never" 中的 'er'。 \n, \t, 等.匹配一个换行符。匹配一个制表符。等 \1...\9匹配第n个分组的子表达式。 \10匹配第n个分组的子表达式，如果它经匹配。否则指的是八进制字符码的表达式。
正则表达式实例
实例描述 python匹配 "python".
实例描述 [Pp]ython 匹配 "Python" 或 "python" rub[ye]匹配 "ruby" 或 "rube" [aeiou]匹配中括号内的任意一个字母 [0-9]匹配任何数字。类似于 [] [a-z]匹配任何小写字母 [A-Z]匹配任何大写字母 [a-zA-Z0-9]匹配任何字母及数字 [^aeiou]除了aeiou字母以外的所有字符
[^0-9]匹配除了数字外的字符
特殊字符类
实例描述 .匹配除 "\n" 之外的任何单个字符。要匹配包括 '\n' 在内的任何字符，请使用象 '[.\n]' 的模式。 \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_]'。