正则表达式 & re模块

正则表达式 & re模块

1. 正则表达式的定义

• 正则表达式是对字符串操作的一种逻辑公式，就是用事先定义好的一些特定字符、及这些特定字符的组合，组成一个“规则字符串”，这个“规则字符串”用来表达对字符串的一种过滤逻辑
• pyhton内置库提供了re模块，提供正则表达式的表达和方法

2. 正则表达式的匹配规则

• 内容匹配规则

表示	含义
\A	表示从字符串的开始处匹配
\Z	表示从字符串的结束处匹配，如果存在换行，只匹配到换行前的结束字符串
\b	匹配一个单词边界，也就是指单词和空格间的位置。例如， ‘py\b’ 可以匹配"python" 中的 ‘py’，但不能匹配 “openpyxl” 中的 ‘py’
\B	匹配非单词边界。 ‘py\b’ 可以匹配"openpyxl" 中的 ‘py’，但不能匹配"python" 中的 ‘py’
\d	匹配任意数字，等价于 [0-9]
\D	匹配任意非数字字符，等价于 [^\d]
\s	匹配任意空白字符，等价于 [\t\n\r\f]
\S	匹配任意非空白字符，等价于 [^\s]
\w	匹配任意字母数字及下划线，等价于[a-zA-Z0-9_]
\W	匹配任意非字母数字及下划线，等价于[^\w]
\\	匹配原义的反斜杠\
.	用于匹配除换行符（\n）之外的所有字符

• 位置限制

表示	含义
^	用于匹配字符串的开始，即行首
$	用于匹配字符串的末尾（末尾如果有换行符\n，就匹配\n前面的那个字符），即行尾

• 定义正则验证次数

表示	含义
*	用于将前面的模式匹配0次或多次（贪婪模式，即尽可能多的匹配）
+	用于将前面的模式匹配1次或多次（贪婪模式）
？	用于将前面的模式匹配0次或1次（贪婪模式）
{m}	用于验证将前面的模式匹配m次
{m,}	用于验证将前面的模式匹配m次或者多次
{m,n}	用于验证将前面的模式匹配大于等于m次并且小于等于n次
*？，+？，？？	即上面三种特殊字符的非贪婪模式（尽可能少的匹配）
{m,n}？	即上面{m,n}的非贪婪版本。
\\	转义字符，在特殊字符前面加上\，特殊字符就失去了其所代表的含义
[ ]	用于标示一组字符，如果^是第一个字符，则标示的是一个补集
|	比如A|B用于匹配 A 或 B
( )	用于匹配括号中的模式，可以在字符串中检索或匹配我们所需要的内容
[\u4e00-\u9fa5]	中文匹配范围

3. re模块使用方法

• 使用 re 模块有两种方式：
  • 一是先使用 re.compile 函数生成一个 Pattern 对象，然后使用 Pattern 对象的一系列方法对文本进行匹配查找
  • 直接使用 re.match, re.search 和 re.findall 等函数直接对文本匹配查找
• 两种方法本质上可以说式一样的，生成Pattern对象后，直接使用的函数即变成了Pattern对象的方法
• 如果一个正则表达式需要用到多次，在多种场合经常需要被用到，出于效率的考虑，我们应该预先编译该正则表达式，生成一个 Pattern 对象，再使用该对象的一系列方法对需要匹配的文件进行匹配，因此常使用第一种方法

3.1 compile 函数

• 用于编译正则表达式，生成一个 Pattern 对象
• 使用形式如下：re.compile(pattern[, flag])
  • pattern 是一个字符串形式的正则表达式
  • flag 是一个可选参数，表示匹配模式，比如忽略大小写，多行模式
• 当然，并不是一定需要先使用该函数生成pattern后，也可以直接在具体的函数方法中输入正则表达式

3.2 match 方法

• match 方法用于查找字符串的头部（也可以指定起始位置）进行一次匹配

• 使用形式：match(string[, pos[, endpos]])

  • string 是待匹配的字符串
  • pos 和 endpos 是可选参数，指定字符串的起始和终点位置，默认值分别是 0 和 len (字符串长度)

• 当匹配成功时，返回一个 Match 对象，如果没有匹配上，则返回 None

• 使用示例如下：

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

• 省略compile 函数的使用

import re
m = re.match(r'\d+','12twothree34four') # 从'e'的位置开始匹配，没有匹配
print(m) # 返回一个 Match 对象
print(m.group(0)) # 可省略 0
print(m.start(0))  # 可省略 0
print(m.end(0))  # 可省略 0
print(m.span(0))  # 可省略 0

• 当匹配成功时返回一个 Match 对象，该对象可使用如下方法：

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

3.3 search 方法

• search 方法用于查找字符串的任何位置，也是一次匹配，只要找到了一个匹配的结果就返回
• 使用形式：search(string[, pos[, endpos]])
• 当匹配成功时，返回一个 Match 对象，如果没有匹配上，则返回 None

3.4 findall 方法

• 搜索整个字符串，获得所有的匹配的结果
• 使用形式： findall(string[, pos[, endpos]])
• 以列表形式返回全部能匹配的子串，如果没有匹配，则返回一个空列表

3.5 finditer 方法

• finditer 方法的行为跟 findall 的行为类似，也是搜索整个字符串，获得所有匹配的结果。但它返回一个顺序访问每一个匹配结果（Match 对象）的迭代器
• 使用示例

import re
pattern = re.compile(r'\d+')
result_iter1 = pattern.finditer('hello 123456 789')
result_iter2 = pattern.finditer('one1two2three3four4', 0, 16)
print(type(result_iter1))
print(type(result_iter2))
print('result1 :')
for m1 in result_iter1: # m1 是 Match 对象
    print ('matching string: {}, position: {}'.format(m1.group(), m1.span()))
print ('result2 :')
for m2 in result_iter2:
    print ('matching string: {}, position: {}'.format(m2.group(), m2.span()))

3.6 split 方法

• split 方法按照能够匹配的子串将字符串分割后返回列表
• 使用形式 ： split(string[, maxsplit])
  • maxsplit 用于指定最大分割次数，不指定将全部分割
• 使用案例：

import re
p = re.compile(r'[\s\,\;]+') 
print (p.split('a,b;; c d')) # 用空白字符或者","或者";"字符分割字符串
# 结果 ：['a', 'b', 'c', 'd']
print (p.split('a,b;; c d', 2)) # 分割2次
# 结果 ：['a', 'b', 'c d']

3.7 sub 方法

• sub 方法用于替换
• 使用形式：sub(repl, string[, count])
  • repl 可以是字符串也可以是一个函数：如果 repl 是字符串，则会使用 repl 去替换字符串每一个匹配的子串，并返回替换后的字符串，另外，repl 还可以使用 \id 的形式来引用分组，但不能使用编号 0；如果 repl 是函数，这个方法应当只接受一个参数（Match 对象），并返回一个字符串用于替换（返回的字符串中不能再引用分组）。
  • count 用于指定最多替换次数，不指定时全部替换
• 示例：

import re

p = re.compile(r'(\w+) (\w+)') # 匹配任意字母数字及下划线, 至少一次
s = 'hello 123, hello 456'
def func(m):
    return 'hi' + ' ' + m.group(2)

print (p.sub(r'hello world', s)) # 使用 'hello world' 替换 'hello 123' 和 'hello 456'
# >>> hello world, hello world
print (p.sub(r'\2 \1', s))  # 引用分组
# >>> 123 hello, 456 hello
print (p.sub(func, s))
# >>> hi 123, hi 456
print (p.sub(func, s, 1))   # 最多替换一次
# >>> hi 123, hello 456

3.8 subn 方法

• subn 方法跟 sub 方法的行为类似，也用于替换
• 使用形式：subn(repl, string[, count])
• 返回一个元组：(sub(repl, string[, count]), 替换次数)，元组有两个元素，第一个元素是使用 sub 方法的结果，第二个元素返回原字符串被替换的次数

import re

p = re.compile(r'(\w+) (\w+)') # 匹配任意字母数字及下划线, 至少一次
s = 'hello 123, hello 456'
def func(m):
    return 'hi' + ' ' + m.group(2)

print (p.subn(r'hello world', s)) # 使用 'hello world' 替换 'hello 123' 和 'hello 456'
# >>> ('hello world, hello world', 2)
print (p.subn(r'\2 \1', s))  # 引用分组
# >>> ('123 hello, 456 hello', 2)
print (p.subn(func, s))
# >>> ('hi 123, hi 456', 2)
print (p.subn(func, s, 1))   # 最多替换一次
# >>> ('hi 123, hello 456', 1)

3.9 匹配中文

• 中文的 unicode 编码范围 主要在[\u4e00-\u9fa5] ，因此用这个范围来匹配中文
• 该范围并不是完整范围，比如没有包括全角（中文）标点，不过，在大部分情况下，应该是够用的
• 常在正则表达式前面加上了两个前缀 ur ，其中 r 表示使用原始字符串， u 表示是 unicode 字符串

---

感谢阅读 若有错误 敬请见谅 ！！！

---