正则表达式_参照书上例 7.8 代码,给定一个匹配模式 'pa\w+\s\w+\s(\d?)+' 和要匹配的三

正则表达式是一个特殊的字符序列，它能帮助你方便的检查一个字符串是否与某种模式匹配。

Python 自1.5版本起增加了re 模块，它提供 Perl 风格的正则表达式模式。

re 模块使 Python 语言拥有全部的正则表达式功能。

compile 函数根据一个模式字符串和可选的标志参数生成一个正则表达式对象。该对象拥有一系列方法用于正则表达式匹配和替换。

re 模块也提供了与这些方法功能完全一致的函数，这些函数使用一个模式字符串做为它们的第一个参数。

本章节主要介绍 Python 中常用的正则表达式处理函数，如果你对正则表达式不了解，可以查看我们的 正则表达式 - 教程。

---

re.match函数

re.match 尝试从字符串的起始位置匹配一个模式，如果不是起始位置匹配成功的话，match()就返回none。

函数语法：

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

函数参数说明：

匹配成功re.match方法返回一个匹配的对象，否则返回None。

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

实例

#!/usr/bin/python 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" # .* 表示任意匹配除换行符（\n、\r）之外的任何单个或多个字符 # (.*?) 表示"非贪婪"模式，只保存第一个匹配到的子串 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)) else: print ("No match!!")

以上实例执行结果如下：

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

---

re.search方法

re.search 扫描整个字符串并返回第一个成功的匹配。

函数语法：

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

函数参数说明：

匹配成功re.search方法返回一个匹配的对象，否则返回None。

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

实例

#!/usr/bin/python3 import re print(re.search('www', 'www.runoob.com').span()) # 在起始位置匹配 print(re.search('com', 'www.runoob.com').span()) # 不在起始位置匹配

以上实例运行输出结果为：

(0, 3)
(11, 14)

实例

#!/usr/bin/python3 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!!")

以上实例执行结果如下：

searchObj.group() :  Cats are smarter than dogs
searchObj.group(1) :  Cats
searchObj.group(2) :  smarter

---

re.match与re.search的区别

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

实例

#!/usr/bin/python3 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!!")

以上实例运行结果如下：

No match!!
search --> matchObj.group() :  dogs

---

检索和替换

Python 的re模块提供了re.sub用于替换字符串中的匹配项。

语法：

re.sub(pattern, repl, string, count=0, flags=0)

参数：

• pattern : 正则中的模式字符串。
• repl : 替换的字符串，也可为一个函数。
• string : 要被查找替换的原始字符串。
• count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配。
• flags : 编译时用的匹配模式，数字形式。

前三个为必选参数，后两个为可选参数。

实例

#!/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

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

compile 函数

compile 函数用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供 match() 和 search() 这两个函数使用。

语法格式为：

re.compile(pattern[, flags])

参数：

• pattern : 一个字符串形式的正则表达式
• flags 可选，表示匹配模式，比如忽略大小写，多行模式等，具体参数为：
• • re.I 忽略大小写
  • re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
  • re.M 多行模式
  • re.S 即为' . '并且包括换行符在内的任意字符（' . '不包括换行符）
  • re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
  • re.X 为了增加可读性，忽略空格和' # '后面的注释

实例

实例

>>>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)

在上面，当匹配成功时返回一个 Match 对象，其中：

• group([group1, …]) 方法用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)；
• start([group]) 方法用于获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0；
• end([group]) 方法用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0；
• span([group]) 方法返回 (start(group), end(group))。

再看看一个例子：

实例

>>>import re >>> pattern = re.compile(r'([a-z]+) ([a-z]+)', re.I) # re.I 表示忽略大小写 >>> m = pattern.match('Hello World Wide Web') >>> print( m ) # 匹配成功，返回一个 Match 对象 <_sre.SRE_Match object at 0x10bea83e8> >>> m.group(0) # 返回匹配成功的整个子串 'Hello World' >>> m.span(0) # 返回匹配成功的整个子串的索引 (0, 11) >>> m.group(1) # 返回第一个分组匹配成功的子串 'Hello' >>> m.span(1) # 返回第一个分组匹配成功的子串的索引 (0, 5) >>> m.group(2) # 返回第二个分组匹配成功的子串 'World' >>> m.span(2) # 返回第二个分组匹配成功的子串索引 (6, 11) >>> m.groups() # 等价于 (m.group(1), m.group(2), ...) ('Hello', 'World') >>> m.group(3) # 不存在第三个分组 Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: no such group

findall

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果有多个匹配模式，则返回元组列表，如果没有找到匹配的，则返回空列表。

注意： match 和 search 是匹配一次 findall 匹配所有。

语法格式为：

re.findall(pattern, string, flags=0)
或
pattern.findall(string[, pos[, endpos]])

参数：

• pattern 匹配模式。
• string 待匹配的字符串。
• pos 可选参数，指定字符串的起始位置，默认为 0。
• endpos 可选参数，指定字符串的结束位置，默认为字符串的长度。

查找字符串中的所有数字：

实例

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

输出结果：

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

多个匹配模式，返回元组列表：

实例

import re

result = re.findall(r'(\w+)=(\d+)', 'set width=20 and height=10')
print(result)

[('width', '20'), ('height', '10')]

re.finditer

和 findall 类似，在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回。

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

参数：

实例

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

输出结果：

12 
32 
43 
3

re.split

split 方法按照能够匹配的子串将字符串分割后返回列表，它的使用形式如下：

re.split(pattern, string[, maxsplit=0, flags=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']

---

正则表达式对象

re.RegexObject

re.compile() 返回 RegexObject 对象。

re.MatchObject

group() 返回被 RE 匹配的字符串。

• start() 返回匹配开始的位置
• end() 返回匹配结束的位置
• span() 返回一个元组包含匹配 (开始,结束) 的位置

---

正则表达式修饰符 - 可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：

---

正则表达式模式

模式字符串使用特殊的语法来表示一个正则表达式。

字母和数字表示他们自身。一个正则表达式模式中的字母和数字匹配同样的字符串。

多数字母和数字前加一个反斜杠时会拥有不同的含义。

标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。

反斜杠本身需要使用反斜杠转义。

由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r'\t'，等价于 \\t )匹配相应的特殊字符。

下表列出了正则表达式模式语法中的特殊元素。如果你使用模式的同时提供了可选的标志参数，某些模式元素的含义会改变。

---

正则表达式实例

字符匹配

字符类

特殊字符类

一.正则表达式概念

1.定义

正则表达式，又称规则表达式。（英语：Regular Expression，在代码中常简写为regex、regexp或RE），计算机科学的一个概念。正则表达式通常被用来检索、替换那些符合某个模式(规则)的文本。正则表达式(Regular Expression)是一种文本模式，包括普通字符（例如，a 到 z 之间的字母）和特殊字符（称为"元字符"）。正则表达式使用单个字符串来描述、匹配一系列匹配某个句法规则的字符串。

2.表达式列表

私信菜鸟007有更多的教程！

3.(?iLmsux)为分组设置模式

这里的”i”, “L”, “m”, “s”, “u”, “x”，它们不匹配任何字串，而是表示对应python中re模块当中的(re.I, re.L, re.M, re.S, re.U, re.X)的6种选项。

可以在python源码中看到：

I = IGNORECASE # 忽略大小写
L = LOCALE # 字符集本地化,为了支持多语言版本的字符集使用环境
U = UNICODE # 使用\w,\W,\b,\B这些元字符时将按照UNICODE定义的属性
M = MULTILINE # 多行模式,改变 ^ 和 $ 的行为
S = DOTALL # '.' 的匹配不受限制,包括换行符
X = VERBOSE # 冗余模式,可以忽略正则表达式中的空白和#号的注释
六种模式在正则表达式中可以同时使用多个的，在 python 里面使用按位或运算符 | 同时添加多个模式如：re.compile(”, re.I|re.M|re.S)

4.反斜杠的使用

在一般的编程语言当中，反斜杠“\”代表反转义字符，在反斜杠后面加一个字符可以表示一种特定的意思，接下来列举几个常见的转义字符.

因为在正则表达式的规则当中，‘\’就是转义字符的意思，前面基本语法规则里也有说到，但是在一般的变成语言中，’\’也有转义字符的意思，所以，如果我们要是写代码的时候用到正则表达式中的’\’的时候，就需要写四个’\’，才可以代表一个真正的反斜杠字符，如:“\\\\”。“\\\\”：这里的第一个和第三个是在编程语言中起转义的作用，果：“\\”，然后在正则表达式中它在进行一次反转义就代表着一个真正的反斜杠字符了。但是在python语言中，我们可以不考虑这个问题。只需要在写好的字符串前面加一个’r’， 告诉编译器这个字符串是个原生字符串，不要转义’\’ 。例如，上个例子中的正则表达式可以使用r”\”表示。因为加上这个’r’，只是告诉python语言不转义这个字符串，但是在正则表达式中还是要符合正则表达式的规则。同样，匹配一个数字的”\d”就可以写成r”\d”。所以，在python中写正则表达式时，要养成一个前面写’r’的习惯。

5.表达式的应用与区别：

（1）.^${}的区别

注意：前面的*,+,?等都是贪婪匹配，也就是尽可能匹配，在一个量词后面加?号使其变成惰性匹配

（2）字符集[] [^]

(3)转义符\

在正则表达式中，有很多有特殊意义的是元字符，比如\d和\s等，如果要在正则中匹配正常的"\d"而不是"数字"就需要对"\"进行转义，变成'\\'。在python中，无论是正则表达式，还是待匹配的内容，都是以字符串的形式出现的，在字符串中\也有特殊的含义，本身还需要转义。所以如果匹配一次"\d",字符串中要写成'\\d'，那么正则里就要写成"\\\\d",这样就太麻烦了。这个时候我们就用到了r'\d'这个概念，此时的正则是r'\\d'就可以了。

（4）贪婪匹配

（5）非贪婪匹配

*? 重复任意次，但尽可能少重复
+? 重复1次或更多次，但尽可能少重复
?? 重复0次或1次，但尽可能少重复
{n,m}? 重复n到m次，但尽可能少重复
{n,}? 重复n次以上，但尽可能少重复
（6）.*?的用法

. 是任意字符
* 是取 0 至 无限长度
? 是非贪婪模式。
何在一起就是 取尽量少的任意字符，一般不会这么单独写，他大多用在：
.*?x 就是取前面任意长度的字符，直到一个x出现
6.re函数方法总结

7.常用函数举例

（1）贪婪与非贪婪模式举例

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())
输出结果：

（2）complie()

#描述
def compile(pattern, flags=0):
 "Compile a regular expression pattern, returning a pattern object."
 # 生成一个正则表达式模式，返回一个Regex对象
 return _compile(pattern, flags)
#参数说明
pattern: 正则表达式
flags: 用于修改正则表达式的匹配方式，就是我们在基本语法规则中说到的(iLmsux)六种模式，默认正常模式
举例：

import re
pattern = re.compile(r"\d")
result = pattern.match("123")
print(result.group())
pattern = re.compile(r"abc d", re.I|re.X)""" I = IGNORECASE # 忽略大小写
 X = VERBOSE # 冗余模式,可以忽略正则表达式中的空白和#号的注释"""
result = pattern.match("AbcD")
print(result.group())
输出：

（3）match()

源码描述：

1. def match(pattern, string, flags=0):
 """Try to apply the pattern at the start of the string, returning a match object, or None if no match was found."""
 # 在字符串的开头匹配pattern，返回Match匹配对象，如果没有不到匹配的对象，返回None。
 return _compile(pattern, flags).match(string)
2. def match(self, string, pos=0, endpos=-1):
 """Matches zero | more characters at the beginning of the string."""
 pass
 # 可以指定匹配的字符串起始位置
#参数说明
# 其他两个参数与compile()当中的意义一致
string: 需要验证的字符串
pos: 设定开始位置，默认0
endpos: 设定结束位置，默认-1
举例：

import re
result = re.match(r"a+\d", "aA123", re.I)
print(result.group())
# 输出结果为aA1 只要pattern匹配完了，则视为成功，并将匹配成功的字符串返回
pattern = re.compile(r"abc d", re.I|re.X)
result = pattern.match("0AbcD5", 1, 5)
print(result.group())
# 输出结果为AbcD 从第1个位置开始，到第5个位置之前的字符串
（4）search()

源码描述：

1. def search(pattern, string, flags=0):
 """Scan through string looking for a match to the pattern, returning a match object, or None if no match was found."""
 # 大致意思与match方法相同，不同的地方在于search时整个字符串任意位置匹配，而match时从特定的位置(pos)开始向后仅匹配一次
 return _compile(pattern, flags).search(string)
2. def search(self, string, pos=0, endpos=-1):
 """Scan through string looking for a match, and return a corresponding match instance. Return None if no position in the string matches."""
 pass
 # 可以指定字符串的子串进行匹配
#参数与match()中的一致
举例：

import re
pattern = re.compile(r"abc d", re.I|re.X)
result = pattern.search("0A2aBcd7")
print(result.group())
# 输出结果为aBcd 在字符串中任意位置只要匹配到就返回结果
pattern = re.compile(r"abc d", re.I|re.X)
matchResult = pattern.match("0AbcD5")
searchResult = pattern.search("0AbcD5")
print(matchResult)
print(searchResult)
# matchResult的结果是None
# searchResult.group()的结果结果为AbcD
# 因为在pattern中第一个位置是a，但是在字符串中第一个位置是0，所以match方法在这里匹配失败

 

（5）group()，groups()和groupdict()

源码描述：

1.def group(self, *args):
 """Return one or more subgroups of the match."""
 # 返回成功匹配的一个或多个子组
 pass
2.def groups(self, default=None):
 """Return a tuple containing all the subgroups of the match, from 1 up to however many groups are in the pattern."""
 # 以元组的格式返回所有分组匹配到的字符
 pass
3.def groupdict(self, default=None):
 """Return a dictionary containing all the named subgroups of the match,keyed by the subgroup name."""
 # 以字典的格式返回所有分组匹配到的字符
 pass
#参数说明：
group中的*args: 如果参数为一个，就返回一个子串；如果参数有多个，就返回多个子串的元组。如果不传任何参数，和传入0一样，将返回整个匹配子串。
groups中的default: 用于给那些没有匹配到的分组做默认值，它的默认值是None
groupdict中的default: 用于给那些没有匹配到的分组做默认值，它的默认值是None
举例：

import re
pattern = re.compile(r"([\w]+) ([\w]+)")
m = pattern.match("Hello World Hi Python")
print(m.group())
# 输出结果为Hello World 第一个分组成功匹配到Hello第二个成功匹配到World 正则表达式已匹配结束
print(m.group(1))
# 输出结果为Hello 取第一个分组成功匹配到Hello
print(m.group(2))
# 输出结果为World 取第二个分组成功匹配到World
pattern = re.compile(r"([\w]+)\.?([\w]+)?")
m = pattern.match("Hello")
print(m.groups())
# 输出结果为('Hello', None) 第一个元素是一个分组匹配到的Hello，因为第二个分组没有匹配到，所以返回None
print(m.groups("Python"))
# 输出结果为('Hello', 'Python') 因为第二个分组没有匹配到，所以返回在groups中设置的默认值
pattern = re.compile(r"(?P<first_str>\w+) (?P<last_str>\w+)")
m = pattern.match("Hello Python")
print(m.groupdict())
# 输出结果为{'first_str': 'Hello', 'last_str': 'Python'} 默认值的用法与group

 

（6）findall()

源码描述：

def findall(self, string, pos=0, endpos=-1):
 """Return a list of all non-overlapping matches of pattern in string."""
 # 返回字符串中所有匹配成功的子串的列表，
 #重点：返回的是一个列表，没有group方法
 pass
#参数说明
# 与match方法一致
举例：

import re
pattern = re.compile(r'\d+')
m = pattern.findall('a1b2c33d4')
print(m)
# 输出['1', '2', '33', '4'] 查找出字符串中的所有数字
m = pattern.findall('a1b2c33d4', 1, 6)
print(m)
# 输出['1', '2', '3'] 在"1b2c3"中查找
(7)finditer()

源码描述：

def finditer(self, string, pos=0, endpos=-1):
 """Return an iterator over all non-overlapping matches for the pattern in string. For each match, the iterator returns a match object."""
 # 返回字符串中所有匹配成功的子串的迭代器
 pass
#参数说明
#与match方法一致
举例：

import re
pattern = re.compile(r'\d+')
m = pattern.finditer('a1b2c33d4')
print(m)
# 输出<callable_iterator object at 0x0000021EB0E70940>迭代器
print(next(m).group())
# 依次输出匹配到的结果 1

 

（8）split()

源码描述：

def split(self, string, maxsplit=0):
 """Split string by the occurrences of pattern."""
 # 返回根据匹配到的的子串将字符串分割后成列表
 pass
#参数说明
#maxsplit: 指定最大分割次数，不指定将全部分割。
举例：

import re
pattern = re.compile(r'\d+')
m = pattern.split('a1b2c3d4e')
print(m)
# 输出['a', 'b', 'c', 'd', 'e'] 根据数字，全部分割
m = pattern.split('a1b2c3d4e', 3)
print(m)
# 输出['a', 'b', 'c', 'd4e'] 只分割三次，后面的不进行分割
9 sub()

源码描述

def sub(self, repl, string, count=0):
 """Return the string obtained by replacing the leftmost non-overlapping occurrences of pattern in string by the replacement repl."""
 # repl替换掉字符串中匹配到的子串，变成新的字符串返回
 pass
#参数说明
repl: 替补内容
string: 原字符串
count: 替换次数,默认全部替换
举例：

import re
pattern = re.compile(r'\s+')
text = "Process finished with exit code 0"
m = pattern.sub('-', text, 3)
print(m)
# 输出结果Process-finished-with-exit code 0 前三个空格被‘-’替换了
10.subn()

源码描述：

def subn(self, repl, string, count=0):
 """Return the tuple (new_string, number_of_subs_made) found by replacing the leftmost non-overlapping occurrences of pattern with the replacement repl."""
 # 返回一个由替换后的结果和替换的次数组成的元组
 pass
#参数说明
与sub()参数含义一致
举例：

import re
pattern = re.compile(r'\s+')
text = "Process finished with exit code 0"
m = pattern.subn('-', text)
print(m)
# 输出结果('Process-finished-with-exit-code-0', 5)
未完待续。。。