python类库31[正则表达式]

 

一 re.search 和 re.match

python提供了2中主要的正则表达式操作：re.match 和 re.search。

match ：只从字符串的开始与正则表达式匹配，匹配成功返回matchobject，否则返回None；
search ：将字符串的所有字串尝试与正则表达式匹配，如果所有的字串都没有匹配成功，返回None，否则返回matchobject；（re.search相当于perl中的默认行为）

 

实例代码：

import  re

def  TestSearchAndMatch():
  s1 = " HelloWorld, I am 30 ! "
  
  w1  =   " World "
  m1  =   re.search(w1, s1)
   if  m1:
     print ( " Find : %s "   %  m1.group())
    
   if  re.match(w1, s1)  ==  None:
     print ( " Cannot match " )
    
  w2  =   " HelloWorld "
  m2  =  re.match(w2, s1)
   if  m2:
     print ( " match : %s "   %  m2.group())

TestSearchAndMatch()
# Find : World
# Cannot match
# match : HelloWorld

 

 

二 re.compile 和 re.ignorecase

re.compile返回regrexobject对象， 用来重复使用regrexobject；

re.ignorecase用来在匹配时忽略大小写；

 

实例代码：

def  TestCompile():
  regex  =   " \d{3}-\d{7} "
  
  regexobject  =  re.compile(regex)
   print (regexobject.search( " AAA 027-4567892 " ).group())
   print (regexobject.search( " BBB 021-1234567 " ).group())
   print (regexobject.search( " CCC 010-123456 " ))

TestCompile()
# 027-4567892
# 021-1234567
# None

def  TestIgnorecase():
   print (re.search( ' world ' ,  " hello world ! " ).group())
   print (re.search( ' World ' ,  " hello world ! " , re.IGNORECASE).group())
   print (re.search( ' World ' ,  " hello world ! " ))
  
TestIgnorecase()
# world
# world
# None

 

 

三 matchobject

matchobject为re.search,re.match等匹配成功后返回的对象，包含了匹配的结果。

在正则表达式中，可以使用()来将部分正则表达式分组且编号，编号从1开始，使用\数字来使用，例如\1 \2 \3，(?P<name>)还可以给分组命名, 使用（？P=name）来使用命名的组。

matchobject.group()包含了所有匹配的内容，等价于matchobject.group(0)，此时的0表示所有的匹配；

matchobject.groups()包含了正则表达式中所有使用()定义的组对应的匹配内容；

matchobject.group(n)，表示返回正则表达式中的第n个组()匹配的内容，此时n不为0， 等价于matchobject.groups()[n-1];

matchobject.lastindex, 表示正则表达式中分组()的个数；

 

实例代码：

def  TestMatchObject():
  m  =  re.match(r " (?P<year>\d{4})-(?P<month>\d{2})-(?P<date>\d{2}) " ,  " 2010-10-01, i am very happy " )
   print (m.group())
   print (m.group(0))
  
   print (m.groups())
  
   print (m.group( 1 ))  
   print (m.groups()[0])
  
   print (m.group( 2 ))  
   print (m.groups()[ 1 ])
  
   print (m.group( 3 ))  
   print (m.groups()[ 2 ])
  
   print (m.groupdict())
  
   print (m.lastindex)

TestMatchObject()
# 2010-10-01
# 2010-10-01
# ('2010', '10', '01')
# 2010
# 2010
# 10
# 10
# 01
# 01
# {'date': '01', 'year': '2010', 'month': '10'}
# 3

 

 

四 re和matchobject的方法split+findall+finditer+sub 

split方法，使用给定的表达式来分割字符串；

findall方法，返回所有的与给定的表达式匹配的一个list；

finditer方法，返回所有与给定的表达式匹配的matchobject的iterator；

sub方法，使用新的字符串替换表达式匹配的字符串；

 

实例代码：

def  TestReAndMatchObjectMethonds():
   # split findall finditer sub  
  s1  =   " I am working in Microsoft ! "
  l  =  re.split( ' \s+ ' , s1)  #  l is list type
   print ( l)
  
  s2  =   " aa 12 bb 3 cc 45 dd 88 gg 89 "
  l2  =  re.findall( ' \d+ ' , s2)
   print (l2)
  
  it  =  re.finditer( ' \d+ ' , s2)  #  it is one iterator type
   for  i  in  it:  #  i is matchobject type
     print  (i.group())
    
  s3  =  re.sub( ' \d+ ' ,  ' 200 ' , s2)
   print (s3)
  
TestReAndMatchObjectMethonds()
# ['I', 'am', 'working', 'in', 'Microsoft', '!']
# ['12', '3', '45', '88', '89']
# 12
# 3
# 45
# 88
# 89
# aa 200 bb 200 cc 200 dd 200 gg 200

 

五 re.search只返回第一个匹配

 

实例代码：

def  TestSearch():
  s1  =   " bb 3 cc 45 dd 88 gg 89 "
  m  =  re.search( ' \d+ ' , s1)
   print (m.group())

TestSearch()
# 3

 

六 非贪婪模式，单行多行模式

1 非贪婪flag (对贪婪标志*和+使用？)
>>> re.findall(r"a(\d+?)", "a23b")
        ['2']
>>> re.findall(r"a(\d+)", "a23b")
        ['23']

注意比较这种情况：
>>> re.findall(r"a(\d+)b", "a23b")
        ['23']
>>> re.findall(r"a(\d+?)b", "a23b")
        ['23']

2 如果你要多行匹配，那么加上re.S和re.M标志
re.S：.将会匹配换行符，默认.不会匹配换行符
>>> re.findall(r"a(\d+)b.+a(\d+)b", "a23b\na34b")
        []
>>> re.findall(r"a(\d+)b.+a(\d+)b", "a23b\na34b", re.S)
        [('23', '34')]
>>>

re.M：^$标志将会匹配每一行，默认^和$只会匹配第一行
>>> re.findall(r"^a(\d+)b", "a23b\na34b")
        ['23']
>>> re.findall(r"^a(\d+)b", "a23b\na34b", re.M)
        ['23', '34']

 

多行查询的实例：

  r = re.compile('... depotFile (.*)',re.M)
  flist = r.findall(fstr)

 

 

完!