Python正则表达式re模块

模块级方法，pattern对象方法，和match对象方法。

一、模块级方法

1.re.compile(pattern, flags = 0)
功能 ：编译为 Pattern对象，提高匹配效率。
参数 ：
pattern ：要编译的正则表达式字符串。
flags ：可选的标志，用于修改正则表达式的行为。

• re.IGNORECASE 对大小写不敏感。
• re.MULTILINE 多行模式。
• re.DOTALL 使 . 匹配任何字符。

返回值 ： Pattern 对象。
示例 ：

import re
pattern = re.compile(r'\d+', re.IGNORECASE)
result = pattern.match('123abc')
print(result)  # <re.Match object; span=(0, 3), match='123'>

2. re.match(pattern, string, flags = 0)
功能： 只匹配字符串的开头部分
参数：
pattern ：正则表达式字符串
string ：目标字符串
flags ：与 re.compile 中的标志相同。

• re.IGNORECASE ：对大小写不敏感。
• re.MULTILINE ：多行模式。
• re.DOTALL ：使 . 匹配任何字符。

返回值： 如果匹配成功，返回一个 Match 对象；否则返回 None 。
示例：

import re
result = re.match(r'\d+', '123abc')
print(result)  # <re.Match object; span=(0, 3), match='123'>
result = re.match(r'\d+', 'abc123')
print(result)  # None

3. re.search(pattern, string, flags = 0)
功能 ： 扫描整个字符串，直到找到第一个匹配项为止。
参数 ：
pattern ：正则表达式字符串。
string ：目标字符串。
flags ：可选的标志。
返回值 ： 如果找到匹配项，返回一个 Match 对象；否则返回 None。
示例 ：

import re
result = re.search(r'\d+', 'abc123')
print(result)  # <re.Match object; span=(3, 6), match='123'>
result = re.search(r'\d+', 'abcdef')
print(result)  # None

4. re.fullmatch(pattern, string, flags = 0)

功能： 要求整个字符串必须完全符合正则表达式
参数：
pattern ：正则表达式字符串。
string ：要匹配的目标字符串。
flags ：可选的标志。
返回值 ：如果整个字符串匹配成功，返回一个 Match 对象；否则返回 None。
示例 ：

import re
result = re.fullmatch(r'\d+', '123')
print(result)  # <re.Match object; span=(0, 3), match='123'>
result = re.fullmatch(r'\d+', '123abc')
print(result)  # None

5. re.findall(pattern, string, flags = 0)
功能 ： 将所有符合的部分，作为列表返回。
参数 ：
pattern ： 正则表达式字符串。
string ：要搜索的目标字符串。
flags ： 可选的标志。
返回值 ：返回一个列表，其中包含所有匹配的子字符串。
示例 ：

import re
result = re.findall(r'\d+', 'abc123def456')
print(result)  # ['123', '456']

6. re.finditer(pattern, string, flags = 0)
功能： 与 re.findall 类似，但返回的是一个迭代器。
参数：
pattern ：正则表达式字符串。
string ：要搜索的目标字符串。
flags ：可选的标志。

返回值： 返回一个迭代器，每次迭代返回一个 Match 对象。
示例 ：

import re
result = re.finditer(r'\d+', 'abc123def456')
for match in result:print(match)  # <re.Match object; span=(3, 6), match='123'>, <re.Match object; span=(9, 12), match='456'>

7. re.split(pattern, string, maxsplit = 0, flags = 0)
功能： 分隔字符串，返回一个列表。
参数：
pattern ：正则表达式字符串。
string ：要分割的目标字符串。
maxsplit ：可选参数，指定最大分割次数。如果省略或为 0，则不限制分割次数。
flags ：可选的标志。
返回值： 返回一个列表，包含分割后的子字符串。
示例：

import re
result = re.split(r'\s+', 'abc def ghi')
print(result)  # ['abc', 'def', 'ghi']
result = re.split(r'\s+', 'abc def ghi', maxsplit=1)
print(result)  # ['abc', 'def ghi']

8. re.sub(pattern, repl, string, count = 0, flags = 0)
功能 ：将匹配项替换为指定的字符串
参数 ：
pattern ：正则表达式字符串。
repl ：要替换的内容，可以是字符串，也可以是一个函数。如果是字符串，其中可以包含\1、\2等反向引用，表示匹配的子组内容；如果是函数，则会将每个匹配的 Match 对象作为参数传递给函数，函数的返回值将作为替换内容
string ：要替换的目标字符串。
count ：可选参数，指定最大替换次数。如果省略或为 0，则不限制替换次数。
flags ：可选的标志。

返回值 ：返回替换后的字符串。
示例 ：

import re
result = re.sub(r'\d+', 'X', 'abc123def456')
print(result)  # abcXdefX
def repl(match):return match.group() + 'X'
result = re.sub(r'\d+', repl, 'abc123def456')
print(result)  # abc123Xdef456X

9. re.subn(pattern, repl, string, count = 0, flags = 0)
功能： 与 re.sub 类似，返回一个元组。
参数： 与 re.sub 相同。
返回值： 返回一个元组，第一个元素是替换后的字符串，第二个元素是替换次数。
示例 ：

import re
result = re.subn(r'\d+', 'X', 'abc123def456')
print(result)  # ('abcXdefX', 2)

10. re.escape(pattern)
功能： 转义特殊字符
参数：
pattern：要转义的正则表达式字符串。
返回值： 返回转义后的字符串。
示例：

import re
result = re.escape('abc.123?')
print(result)  # abc\.123\?

11. re.purge()
功能 ： 清除缓存
示例：

import re
re.purge()

12. re.error
功能： 语法错误时，抛出 re.error 异常。
示例：

import re
try:re.compile(r'(')
except re.error as e:print(e)  # 输出：unbalanced parenthesis

二、Pattern对象方法

当使用re.compile()编译正则表达式后，会得到一个Pattern对象。Pattern对象具有以下方法：
1.Pattern.search(string[, pos[, endpos]])

功能 ：搜索第一个匹配的子字符串，与 re.search 的功能相同
参数 ：
string ：要搜索的目标字符串。
pos ：可选参数，指定搜索的起始位置，默认为 0。
endpos ：可选参数，指定搜索的结束位置，默认为字符串的长度。

返回值 ：如果找到匹配项，返回一个 Match 对象；否则返回 None。
示例 ：

import re
pattern = re.compile(r'\d+')
result = pattern.search('abc123def456')
print(result)  # <re.Match object; span=(3, 6), match='123'>

2. Pattern.match(string[, pos[, endpos]])
功能： 与 re.match 的功能相同
参数 ： 与 Pattern.search 相同。
返回值： 如果匹配成功，返回一个 Match 对象；否则返回 None。
示例：

import re
pattern = re.compile(r'\d+')
result = pattern.match('123abc')
print(result)  # <re.Match object; span=(0, 3), match='123'>

3. Pattern.fullmatch(string[, pos[, endpos]])
功能 ：与 re.fullmatch 的功能相同
参数 与 Pattern.search 相同。
返回值 ：如果整个字符串匹配成功，返回一个 Match 对象；否则返回 None。
示例 ：

import re
pattern = re.compile(r'\d+')
result = pattern.fullmatch('123')
print(result)  # <re.Match object; span=(0, 3), match='123'>

4. Pattern.findall(string[, pos[, endpos]])
功能： 与 re.findall 的功能相同
参数： 与 Pattern.search 相同。
返回值： 返回一个列表，包含所有匹配的子字符串。
示例：

import re
pattern = re.compile(r'\d+')
result = pattern.findall('abc123def456')
print(result)  # ['123', '456']

5. Pattern.finditer(string[, pos[, endpos]])
功能 ：与 re.finditer 的功能相同
参数 与 Pattern.search 相同。
返回值 ：返回一个迭代器，每次迭代返回一个 Match 对象。
示例 ：

import re
pattern = re.compile(r'\d+')
result = pattern.finditer('abc123def456')
for match in result:print(match)  # <re.Match object; span=(3, 6), match='123'>, <re.Match object; span=(9, 12), match='456'>

6. Pattern.split(string, maxsplit = 0)
功能 ： 与 re.split 的功能相同
参数 ：
string：要分割的目标字符串。
maxsplit ：可选参数，指定最大分割次数。
返回值 ： 返回一个列表，包含分割后的子字符串。
示例 ：

import re
pattern = re.compile(r'\s+')
result = pattern.split('abc def ghi')
print(result)  # ['abc', 'def', 'ghi']

7. Pattern.sub(repl, string, count = 0)

功能 ：与 re.sub 的功能相同
参数 ：
repl ：要替换的内容。
string ：要替换的目标字符串。
count：可选参数，指定最大替换次数。
返回值 ：返回替换后的字符串。
示例 ：

import re
pattern = re.compile(r'\d+')
result = pattern.sub('X', 'abc123def456')
print(result)  # abcXdefX

8. Pattern.subn(repl, string, count = 0)
功能 ： 与 Pattern.sub 类似，返回一个元组
参数 与 Pattern.sub 相同。
返回值 ： 返回一个元组，第一个元素是替换后的字符串，第二个元素是替换次数。
示例 ：

import re
pattern = re.compile(r'\d+')
result = pattern.subn('X', 'abc123def456')
print(result)  # ('abcXdefX', 2)

三、Match对象方法

当使用正则表达式匹配成功后，会得到一个 Match 对象。Match 对象具有以下方法：

1. Match.group([group1, ...])

功能 ：返回一个或多个匹配的子组
参数 ：
group1, ...：可选参数，指定要返回的子组编号。编号从 1 开始，也可以使用子组的名称（如果有命名子组）。

返回值 ：如果只传入一个参数（或不传参数），则返回整个匹配的字符串；如果传入多个参数，则返回一个元组，包含所有指定子组的匹配结果。
示例 ：

import re
match = re.match(r'(\d+)([a-z]+)', '123abc')
print(match.group())  # 123abc
print(match.group(1))  # 123
print(match.group(2))  # abc
print(match.group(1, 2))  # ('123', 'abc')

2. Match.groups(default = None)
功能 ： 返回一个元组，包含所有匹配的子组
参数 ：
default：可选参数，指定未匹配的子组的默认值，默认为 None。
返回值 ： 返回一个元组，包含所有匹配的子组。如果没有匹配的子组，则返回一个包含默认值的元组。
示例 ：

import re
match = re.match(r'(\d+)([a-z]+)', '123abc')
print(match.groups())  # ('123', 'abc')
match = re.match(r'(\d+)([a-z]+)?', '123')
print(match.groups())  # ('123', None)
print(match.groups('default'))  # ('123', 'default')

3. Match.groupdict(default = None)

功能 ：返回一个字典，包含所有命名子组的匹配结果
参数 ：
default：可选参数，指定未匹配的命名子组的默认值，默认为 None。
返回值 ：返回一个字典，包含所有命名子组的匹配结果。
示例 ：

import re
match = re.match(r'(?P<num>\d+)(?P<letters>[a-z]+)', '123abc')
print(match.groupdict())  # {'num': '123', 'letters': 'abc'}
match = re.match(r'(?P<num>\d+)(?P<letters>[a-z]+)?', '123')
print(match.groupdict())  # {'num': '123', 'letters': None}
print(match.groupdict('default'))  # {'num': '123', 'letters': 'default'}

4. Match.start([group])
功能 ： 返回匹配的子组的起始位置。
参数 ：
group ：可选参数，指定子组编号。
返回值 ： 返回匹配的起始位置（索引）。如果未指定子组编号，则返回整个匹配的起始位置。
示例 ：

import re
match = re.match(r'(\d+)([a-z]+)', '123abc')
print(match.start())  # 0
print(match.start(1))  # 0
print(match.start(2))  # 3

5. Match.end([group])
功能 ：返回匹配的子组的结束位置（索引）
参数 ：
group：可选参数，指定子组编号。
返回值 ：返回匹配的结束位置（索引）。如果未指定子组编号，则返回整个匹配的结束位置。
示例 ：

import re
match = re.match(r'(\d+)([a-z]+)', '123abc')
print(match.end())  # 6
print(match.end(1))  # 3
print(match.end(2))  # 6

6. Match.span([group])__
   功能 ： 返回一个元组，包含匹配的子组的起始和结束位置（索引）
   参数 ：
   group：可选参数，指定子组编号。
   返回值 ： 返回一个元组，包含起始和结束位置（索引）。如果未指定子组编号，则返回整个匹配的起始和结束位置。
   示例 ：

import re
match = re.match(r'(\d+)([a-z]+)', '123abc')
print(match.span())  # (0, 6)
print(match.span(1))  # (0, 3)
print(match.span(2))  # (3, 6)

以上即常见的Python正则表达式re模块用法