Python正则表达式

re.match

re.match(pattern, string, flags=0)

从字符串起始位置匹配一个模式，
成功匹配则返回一个’匹配对象’，否则返回None
其中flags是标志位，用来控制正则表达式的匹配方式，共有如下几种

flag	描述
re.I	使匹配对大小写不敏感 case Insensitive
re.L	做本地化识别（Locale-aware）匹配
re.M	多行匹配，影响 ^ 和 $ Multiline
re.S	使 . 匹配包括换行在内的所有字符
re.U	根据Unicode字符集解析字符。这个标志影响 \w, \W, \b, \B.
re.X	该标志通过给予你更灵活的格式以便你将正则表达式写得更易于理解。

匹配对象方法

• group(num=0)
  
  • 参数默认为0，表示返回整个匹配的结果
  • num为其他正整数时表示返回被()缓存的组的结果
  • 当num为多个组号时，返回一个包含那些组对应值的元组
• groups()
  
  • 返回一个包含所有匹配小组字符串的元组
• span(num=0)
  
  • 返回匹配的下标范围的元组，当num不为0时，表示返回被()缓存的匹配部分的下标范围
• start(num=0)
  
  • 返回匹配的下标范围的起始点，当num不为零时，同样返回分组匹配的字符串的下标起位置
• end(num=0)
  
  • 返回匹配的下标范围的终止点，当num不为零时，同样返回分组匹配的字符串的下标起位置

import re
print(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配
print(re.match('com', 'www.runoob.com'))         # 不在起始位置匹配

输出

(0,3) #注意第二个下标是不包含的
None

#!/usr/bin/python3
import re

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 ("matchObj.group(1,2) : ", matchObj.group(1,2))
   print ("matchObj.groups() : ", matchObj.groups())
else:
   print ("No match!!")

输出结果

matchObj.group() :  Cats are smarter than dogs
matchObj.group(1) :  Cats
matchObj.group(2) :  smarter
matchObj.group(1,2) :  ('Cats', 'smarter')
matchObj.groups() :  ('Cats', 'smarter')

re.search

re.search(pattern, string, flags=0)

扫描整个字符串，返回第一个成功的匹配

re.match与re.search的区别
re.match只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；而re.search匹配整个字符串，直到找到一个匹配。

re.sub

re.sub(pattern, repl, string, count=0)
- repl : 替换的字符串，也可为一个函数。
- count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

#!/usr/bin/python3
import re

phone = "2004-959-559 # 这是一个电话号码 #"

# 删除'#'
num = re.sub(r'#', "", phone)
print ("电话号码 : ", num)

# 移除非数字的内容
num = re.sub(r'\D', "", phone)
print ("电话号码 : ", num)

运行结果

电话号码 :  2004-959-559 这是一个电话号码
电话号码 :  2004959559

可以看出re.sub的参数count若为0，会替换所有的匹配，即若改成num = re.sub(r'#', "", phone,1) 结果中第二个#没有被替换

repl参数也可以是一个函数
以下实例中将字符串中的匹配的数字乘于 2：

#!/usr/bin/python

import re

# 将匹配的数字乘于 2
def double(matched):
    value = int(matched.group('value'))
    return str(value * 2)

s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s))

输出结果为

A46G8HFD1134

其中(?P<value>)与()的功能类似，也是起到分组缓存的作用，然而该写法使该组可以用名字’value’来引用，因此double函数中有matched.group('value')
从输出结果可以看到所有的数字都被乘以二了，当repl的参数是一个函数的时候，相当于将匹配对象作为参数传给repl，然后由该函数对匹配对象进行修改

re.compile

re.compile(pattern[, flags])

用于编译正则表达式，生成一个正则表达式对象，可以传给match()和search()作为参数使用

>>>import re
>>> pattern = re.compile(r'\d+')                    # 用于匹配至少一个数字
>>> m = pattern.match('one12twothree34four')        # 查找头部，没有匹配
>>> print m
None
>>> m = pattern.match('one12twothree34four', 2, 10) # 从'e'的位置开始匹配，没有匹配
>>> print m
None
>>> m = pattern.match('one12twothree34four', 3, 10) # 从'1'的位置开始匹配，正好匹配
>>> print m                                         # 返回一个 Match 对象
<_sre.SRE_Match object at 0x10a42aac0>
>>> m.group(0)   # 可省略 0
'12'
>>> m.start(0)   # 可省略 0
3
>>> m.end(0)     # 可省略 0
5
>>> m.span(0)    # 可省略 0
(3, 5)

regex.findall

findall(string[, pos[, endpos]])

这是一个正则表达式（reg expression）的方法，在string中查找所有regex表示的子串，返回列表
pos参数为搜索的起始位置，endpos为结束位置（结束字符串下标+1，因为像list一样，左边的下标是不包含的）
还有另外一个函数
regex.finditer(string[, pos[, endpos]])
也是同样的作用，只不过返回迭代器

import re

pattern = re.compile(r'\d+')   # 查找数字
result1 = pattern.findall('runoob 123 google 456')
result2 = pattern.findall('run88oob123google456', 0, 10)

print(result1)
print(result2)

结果

['123', '456']
['88', '12']

re.finditer

re.finditer(pattern, string, flags=0)

该函数和findall类似，但返回的是迭代器，且它不是regex的方法

import re

it = re.finditer(r"\d+","12a32bc43jf3") 
for match in it: 
    print (match.group() )

结果

12 
32 
43 
3

re.split

re.split(pattern, string[, maxsplit=0, flags=0])

split 方法按照能够匹配的子串将字符串分割后返回（匹配的字符串作为分割点）maxsplit参数指定最大分割次数，也就是最多分割前几个匹配，0为不限

>>>import re
>>> re.split('\W+', 'runoob, runoob, runoob.')
['runoob', 'runoob', 'runoob', '']
>>> re.split('(\W+)', ' runoob, runoob, runoob.') 
['', ' ', 'runoob', ', ', 'runoob', ', ', 'runoob', '.', '']
>>> re.split('\W+', ' runoob, runoob, runoob.', 1) 
['', 'runoob, runoob, runoob.']

>>> re.split('a*', 'hello world')   # 对于一个找不到匹配的字符串而言，split 不会对其作出分割
['hello world']