正则表达式(python)——2

常见正则表达式函数于方法

函数/方法	描述
re模块的函数
compile(pattern,flags=0)	对pattern进行编译,并返回一个regex对象
re模块的函数和regex对象的方法
match(pattern,string,flags=0)	用pattern匹配字符串string,如果匹配成功,则返回匹配对象;否则返回None
search(pattern,string,flags=0)	在string中查找pattern的第一次出现,返回匹配对象或者None
findall(pattern,string[,flag])	在string中查找pattern的所有(非重复)出现,返回一个匹配对象的列表
finditer(pattern,string[,flag])	和findall()相同,但返回的不是列表而是迭代器;对于每个匹配，该迭代器返回一个匹配对象
匹配对象的方法
split(pattern,string,max=0)	根据pattern中的分隔符把string分割为一个列表,返回成功匹配的列表,最多分割max次(默认分割所有匹配的地方)
sub(pattern,repl,string,max=0)	把string中所有匹配pattern的地方替换成repl，如果max值没给出,则对所有匹配的地方进行替换.
group(num=0)	返回全部匹配对象(或指定编号是num的子组)
groups()	返回一个包含全部匹配的子组的元组(如果没有成功匹配,就返回一个空元组)

 1. 使用compile()编译正则表达式

　　在陌生匹配之前,正则表达式模式必须先背编译成regex对象。由于正则表达式在执行过程中被多次用于比较，使用预编译可以提升执行性能。

regex =  re.compile('\d+(\.\d*)?')
print re.search(regex, "test1234.567").group()
print regex.search("test1234.567").group()

2. 匹配对象和group(),groups()方法

　　在处理正则表达式时，除regex对象外，还有另一种对象类型--匹配对象。这些对象是在match()或search()被成功调用之后所返回的结果。匹配对象有两个主要方法:group()和groups()。

　　group()方法或者返回所有匹配对象或是根据要求返回某个特定子组。groups()返回一个包含唯一或所有子组的元组。如果正则表达式中没有子组的话，groups()将返回一个空元组，而group()仍会返回全部匹配对象。

teststr = "name:Jack phone:123456"
m = re.search("name:(.*)phone:(.*)", teststr)
print 'name:{}'.format(m.group(1))
print 'phone:{}'.format(m.group(2))
print 'name:{}'.format(m.groups()[0])
print 'phone:{}'.format(m.groups()[1])

3. 用match()匹配字符串

　　match()函数尝试从字符串的开头开始对模式进行匹配。如果匹配成功,就返回一个匹配对象,而如果匹配失败,就返回None。匹配对象的group()方法可以用来显示那个成功的匹配。

m = re.match('foo', 'food on table')
if m is not None:
    print m.group()

4. search()在一个字符串中查找一个模式(搜索与匹配的比较)

　　通常,要搜索的模式出现在一个字符串中间的几率比出现在字符串开头的几率更大一些。这时就可用search()。search()和match()的工作方式一样,不同之处在于search()会检查参数字符串任意位置的地方与给定的正则表达式的匹配情况。如果搜索到成功的匹配，会返回一个匹配对象，否则返回None。

m = re.match('foo','seafood')   # no match
if m is not None:
    print m.group()

m = re.search('foo', 'seafood') # success
if m is not None:
    print m.group()

5. 示例

 

# -*- coding: cp936 -*-
import re

#1. 匹配多个字符串
bt = 'bat|bet|bit'
m = re.search(bt, 'He bit bet')
if m is not None:
    print m.group()
m = re.findall(bt, 'He bit bet')
print m

#2. 匹配单个字符(.)
patt314 = '3.14'
pi_patt = '3\.14'
m = re.match(pi_patt, '3.14')
if m is not None: print m.group()

m = re.match(patt314, '3014')
if m is not None: print m.group()

#3. 创建字符集合([])
m = re.match('[cr][23][dp][o2]', 'c3po')
if m is not None: print m.group()

#4. 重复、特殊字符和子组
patt = '\w+@(\w+\.)?\w+\.com'
print re.match(patt, 'nobody@XXX.com').group()
print re.match(patt, 'nobody@www.xxx.com').group()
patt = '\w+@(\w+\.)*\w+\.com'
print re.match(patt, 'nobody@www.xxx.yyy.com').group()
m = re.match('(\w{3})-(\d{3})', 'abc-123')
print m.group()     #所有匹配的部分,和m.group(0)相同
print m.group(1)    #匹配的子组1
print m.group(2)    #匹配的子组2
print m.groups()    #所有匹配子组 ('abc','123')
m = re.match('(a(b))','ab') #两个子组
print m.group(),m.group(1),m.group(2),m.groups()

#5. 从字符串的开头或结尾匹配及在单词边界上的匹配
re.search('^The', 'The end.')   #匹配
re.search('^The', 'end.The')    #不匹配
re.search(r'\bthe','bit thedog')    #匹配,单词左边界
#r'\bthe'中的r表示原始字符串(raw strings),即\b会被理解成一个正则表达式的一个特殊符号,而不是退格键
re.search(r'\bthe', 'bit the dog')  #匹配
re.search(r'\bthe','bitthe dog')    #不匹配
re.search(r'\Bthe', 'bitthe dog')   #匹配,单词右边界
re.search(r'\Bthe', 'bit the dog')  #不匹配

#6. 用findall()找到每个出现的匹配部分
print re.findall('c(.)r', 'carry the barcardi to the car')  #结果: ['a','a','a']
print re.findall('c.r', 'carry the barcardi to the car')    #结果: ['car', 'car', 'car']

#7. 用sub()[和subn()]进行搜索和替换
print re.sub('X','Mr. Smith', 'attn: X\n\nDear X,\n')
print re.subn('[ae]', 'X', 'abcdef')    #结果: ('XbcdXf', 2)

#8. 用split()分割(分割模式)
# re模块和正则表达式的方法split()与字符串的split()方法相似,前者根据正则表达式模式分割
# 字符串,后者根据固定的字符串分割.
print "123\n\n456\n789".split('\n')  #结果: ['123', '', '456', '789']
print re.split('\n+', "123\n\n456\n789")    #结果: ['123', '456', '789']

#9. 贪心匹配
# 正则表达式本身默认是贪心匹配的。即,如果正则表达式模式中使用到通配字,那它在按照从左到右
# 的顺序求值时,会尽量抓取满足模式的最长字符串.
testdata = 'gov::123143294538-6-8'
patt = '.+(\d+-\d+-\d+)'
print re.match(patt, testdata).group(1) #结果: 8-6-8
print re.search('\d+-\d+-\d+', testdata).group() #结果: 123143294538-6-8
# 解决贪心匹配的一个办法是用"非贪婪"操作符"?",这个操作符可以用在*,+,或?的后面.它的作用是要求
# 正则表达式引擎匹配的字符越少越好.
print re.match('.+?(\d+-\d+-\d+)', testdata).group(1)   #结果: 123143294538-6-8