python中re模块

1.定义

正则表达式是一个特殊的字符序列，能方便的检查一个字符串是否与某种模式匹配。re模块使得python拥有全部的正则表达式功能。

2.用途

通过使用正则表达式，可以：
测试字符串内的模式。—— 例如，可以测试输入字符串，以查看字符串内是否出现电话号码模式或信用卡号码模式。这称为数据验证。
替换文本。—— 可以使用正则表达式来识别文档中的特定文本，完全删除该文本或者用其他文本替换它。
基于模式匹配从字符串中提取子字符串。—— 可以查找文档内或输入域内特定的文本。

3.语法

'.'     匹配所有字符串，除\n以外
'-'     表示范围[0-9]
'*'     匹配前面的子表达式零次或多次。要匹配 * 字符，请使用 \*。
'+'     匹配前面的子表达式一次或多次。要匹配 + 字符，请使用 \+
'^'     匹配字符串开头
'$'     匹配字符串结尾 re
'\'     转义字符， 使后一个字符改变原来的意思，如果字符串中有字符*需要匹配，可以\*或者字符集[*] re.findall(r'3\*','3*ds')结['3*']
'*'     匹配前面的字符0次或多次 re.findall("ab*","cabc3abcbbac")结果：['ab', 'ab', 'a']
'?'     匹配前一个字符串0次或1次 re.findall('ab?','abcabcabcadf')结果['ab', 'ab', 'ab', 'a']
'{m}'   匹配前一个字符m次 re.findall('cb{1}','bchbchcbfbcbb')结果['cb', 'cb']
'{n,m}' 匹配前一个字符n到m次 re.findall('cb{2,3}','bchbchcbfbcbb')结果['cbb']
'\d'    匹配数字，等于[0-9] re.findall('\d','电话:10086')结果['1', '0', '0', '8', '6']
'\D'    匹配非数字，等于[^0-9] re.findall('\D','电话:10086')结果['电', '话', ':']
'\w'    匹配字母和数字，等于[A-Za-z0-9] re.findall('\w','alex123,./;;;')结果['a', 'l', 'e', 'x', '1', '2', '3']
'\W'    匹配非英文字母和数字,等于[^A-Za-z0-9] re.findall('\W','alex123,./;;;')结果[',', '.', '/', ';', ';', ';']
'\s'    匹配空白字符 re.findall('\s','3*ds \t\n')结果[' ', '\t', '\n']
'\S'    匹配非空白字符 re.findall('\s','3*ds \t\n')结果['3', '*', 'd', 's']
'\A'    匹配字符串开头
'\Z'    匹配字符串结尾
'\b'    匹配单词的词首和词尾，单词被定义为一个字母数字序列，因此词尾是用空白符或非字母数字符来表示的
'\B'    与\b相反，只在当前位置不在单词边界时匹配
[]      是定义匹配的字符范围。比如 [a-zA-Z0-9] 表示相应位置的字符要匹配英文字符和数字。[\s*]表示空格或者*号
'(?P<name>...)'  分组，除了原有编号外在指定一个额外的别名 
re.search("(?P<province>[0-9]{4})(?P<city>[0-9]{2})(?P<birthday>[0-9]{8})","371481199306143242").groupdict("city") 
结果{'province': '3714', 'city': '81', 'birthday': '19930614'}

4.模式

贪婪模式和非贪婪模式

正则表达式通常使用于查找匹配字符串。python里数量词默认是贪婪的，总是尝试匹配尽可能多的字符；非贪婪模式正好相反，总是尝试匹配尽可能少的字符。

使用方法

在python中默认采用的是贪婪模式，使用非贪婪模式的话，只需要在量词后面直接加上一个问号”?”。

例子当中已经匹配到了“ab”时已经可以使整个表达式匹配成功，但是由于采用的是贪婪模式，所以还需要往后继续匹配，一直到匹配到最后一个”b”的时候，后面已经没有可以成功匹配的字符串了，匹配结束。返回匹配结果“abbbbbb”。所以，我们可以将贪婪模式理解为：在整个表达式匹配成功的前提下，尽可能多的匹配。

非贪婪模式也就是将我们例子中的正则表达式“ab+”改为”ab+?”，当匹配到“ab”时，已经匹配成功，直接结束匹配，不在向后继续尝试，返回匹配成功的字符串”ab”。
所以，我们可以将非贪婪模式理解为：在整个表达式匹配成功的前提下，尽可能少的匹配

import re

example = "<div>test1</div><div>test2</div>"

greedPattern = re.compile("<div>.*</div>")
notGreedPattern = re.compile("<div>.*?</div>")

greedResult = greedPattern.search(example)
notGreedResult = notGreedPattern.search(example)

print("greedResult = %s" % greedResult.group())
print("notGreedResult = %s" % notGreedResult.group())
[python@master test]$ python3 a.py 
greedResult = <div>test1</div><div>test2</div>
notGreedResult = <div>test1</div>

能达到同样匹配结果的贪婪与非贪婪模式，通常是贪婪模式的匹配效率较高。所有的非贪婪模式，都可以通过修改量词修饰的子表达式，转换为贪婪模式。贪婪模式可以与固化分组结合，提升匹配效率，而非贪婪模式却不可以。

5.使用re模块

反斜杠的困扰

在 python 的字符串中，\ 是被当做转义字符的。在正则表达式中，\ 也是被当做转义字符。这就导致了一个问题：如果你要匹配 \ 字符串，那么传递给 re.compile() 的字符串必须是"\\\\"。

由于字符串的转义，所以实际传递给 re.compile() 的是"\\"，然后再通过正则表达式的转义，"\\" 会匹配到字符"\"。这样虽然可以正确匹配到字符 \，但是很麻烦，而且容易漏写反斜杠而导致 Bug。那么有什么好的解决方案呢？

原始字符串很好的解决了这个问题，通过在字符串前面添加一个r，表示原始字符串，不让字符串的反斜杠发生转义。那么就可以使用r"\\"来匹配字符\了。

re.compile()

编译正则表达式模式，返回一个对象。可以把常用的正则表达式编译成正则表达式对象，方便后续调用及提高效率。

re.compile(pattern,flags=0)

pattern 指定编译时的表达式字符串

flags 编译标志位，用来修改正则表达式的匹配方式。支持 re.L|re.M 同时匹配

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

import re
content = 'Citizen wang , always fall in love with neighbour，WANG'
rr = re.compile(r'wan\w', re.I) # 不区分大小写
print(type(rr))
a = rr.findall(content)
print(type(a))
print(a)
[python@master test]$ python3 b.py 
<class 're.Pattern'>
<class 'list'>
['wang', 'WANG']

re.match

尝试从一个字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，则返回None。

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

pattern: 待匹配的正则表达式
string: 待查找的字符串
flags（可选参数）: 标志位，控制正则表达式的匹配方式。re.I(ignore) re.L(local) re.M(many lines) re.S(sum) re.U(unicode) re.X
返回值：匹配成功返回匹配对象（group(num=0) / groups() 返回的是一个元组），匹配失败返回None

我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式

group(num=0) 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。

groups() 返回一个包含所有小组字符串的元组，从 1 到所含的小组号。

列子1：

[python@master test]$  more  d.py
# -*- coding: UTF-8 -*-

import re
print(re.match('www', 'www.runoob.com').span())  # 在起始位置匹配
print(re.match('com', 'www.runoob.com'))         # 不在起始位置匹配
[python@master test]$ python3 d.py 
(0, 3)
None

例子二：

[python@master test]$ more c.py 
import re

line = "Cats are Smarter than dogs"
# re.M：多行匹配
# re.I:忽略大小写进行匹配
# match()以元组形式返回匹配成功的对象
match_obj = re.match(r"(.*) are (.*?) .*", line, re.M | re.I)
if match_obj:
    print("match_obj.group(): ", match_obj.group())
    print("match_obj.group(1): ", match_obj.group(1))
    print("match_obj.group(2): ", match_obj.group(2))
    print("match_obj.group(3): ", match_obj.group(1,2))
    print("match_obj.groups(): ", match_obj.groups())
else:
    print("None match!")
print("*" * 98)
[python@master test]$ python3 c.py 
match_obj.group():  Cats are Smarter than dogs
match_obj.group(1):  Cats
match_obj.group(2):  Smarter
match_obj.group(3):  ('Cats', 'Smarter')
match_obj.groups():  ('Cats', 'Smarter')
**************************************************************************************************

re.search

扫描整个字符串并返回第一个成功的匹配。
函数语法：
re.search(pattern, string, flags=0)
函数参数说明：
pattern        匹配的正则表达式
string          要匹配的字符串。
flags            标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

匹配成功re.search方法返回一个匹配的对象，否则返回None。
我们可以使用group(num) 或 groups() 匹配对象函数来获取匹配表达式。
group(num=0) 匹配的整个表达式的字符串，group() 可以一次输入多个组号，在这种情况下它将返回一个包含那些组所对应值的元组。
groups() 返回一个包含所有小组字符串的元组，从 1 到所含的小组号。

例子1：

[python@master test]$ more a.py 
# -*- coding: UTF-8 -*- 
 
import re
print(re.search('www', 'www.runoob.com').span())  # 在起始位置匹配
print(re.search('com', 'www.runoob.com').span())         # 不在起始位置匹配
[python@master test]$ python3 a.py 
(0, 3)
(11, 14)

例子2：

[python@master test]$ more b.py 
import re
 
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))
else:
   print("Nothing found!!")
[python@master test]$ python3 b.py 
searchObj.group() :  Cats are smarter than dogs
searchObj.group(1) :  Cats
searchObj.group(2) :  smarter

re.match与re.search的区别

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

[python@master test]$ more c.py 
import re
 
line = "Cats are smarter than dogs";
 
matchObj = re.match( r'dogs', line, re.M|re.I)
if matchObj:
   print("match --> matchObj.group() : ", matchObj.group())
else:
   print("No match!!")
 
matchObj = re.search( r'dogs', line, re.M|re.I)
if matchObj:
   print("search --> matchObj.group() : ", matchObj.group())
else:
   print("No match!!")
[python@master test]$ python3 c.py 
No match!!
search --> matchObj.group() :  dogs

re.sub()

Python 的 re 模块提供了re.sub用于替换字符串中的匹配项。
语法：
re.sub(pattern, repl, string, count=0, flags=0)
参数：
pattern       正则中的模式字符串。
repl            替换的字符串，也可为一个函数。
string         要被查找替换的原始字符串。
count         模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。

[python@master test]$ more d.py
import re
 
phone = "2004-959-559 # 这是一个电话号码"
 
# 删除注释
num = re.sub(r'#.*$', "", phone)
print ("电话号码 : ", num)
 
# 移除非数字的内容
num = re.sub(r'\D', "", phone)
print ("电话号码 : ", num)
[python@master test]$ python3 d.py 
电话号码 :  2004-959-559 
电话号码 :  2004959559

repl 参数是一个函数

以下实例中将字符串中的匹配的数字乘于 2

[python@master test]$ more e.py 
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))
[python@master test]$ python3 e.py 
A46G8HFD1134

findall()

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表。
注意： match 和 search 是匹配一次 findall 匹配所有。
语法格式为：
findall(string[, pos[, endpos]])
参数：
string           待匹配的字符串。
pos              可选参数，指定字符串的起始位置，默认为 0。
endpos           可选参数，指定字符串的结束位置，默认为字符串的长度。
查找字符串中的所有数字：

[python@master test]$ more a.py 
import re
 
pattern = re.compile(r'\d+')   # 查找数字
result1 = pattern.findall('runoob 123 google 456')
result2 = pattern.findall('run88oob123google456', 0, 10)
 
print(result1)
print(result2)
[python@master test]$ python3 a.py 
['123', '456']
['88', '12']

re.finditer()

和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。
re.finditer(pattern, string, flags=0)
参数：
pattern         匹配的正则表达式
string         要匹配的字符串。
flags           标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等。

[python@master test]$ more d.py 
import re
 
it = re.finditer(r"\d+","12a32bc43jf3") 
for match in it: 
    print (match.group() )
[python@master test]$ python3 d.py 
12
32
43
3

re.split()

split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：
re.split(pattern, string[, maxsplit=0, flags=0])
参数：
pattern           匹配的正则表达式
string           要匹配的字符串。
maxsplit         分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数。
flags             标志位，用于控制正则表达式的匹配方式，如：是否区分大小写，多行匹配等等

>>> 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')
['hello world']# 对于一个找不到匹配的字符串而言，split 不会对其作出分割