广西网络公司网站建设网络推广营销公司
模块级方法，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
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模块用法