Python标准库 - re（正则表达式）正则表达式是一个非常强大且实用的字符串处理方法，通过正则表达式，就能定义文字规

正则表达式是一个非常强大且实用的字符串处理方法，通过正则表达式，就能定义文字规则，接着就能从一段文字里，找出符合规则的字符，几乎常见的程序语言，都有支持正则表达式的操作，这篇教程将会介绍 Python 里，专门操作正则表达式的标准函数库 re。

re 常用方法

下方列出几种 re 模块常用的方法 ：

方法	参数	说明
compile()	pattern	创建一个正则表达式的规则。
search()	pattern, string	寻找第一个匹配的字符，如果没有匹配，返回 None。( 还可额外设置 pos 和 endpos，默认 0，可指定从第几个开始。
match()	pattern, string	从开头开始，寻找第一个匹配的字符。
fullmatch()	pattern, string	返回整个字符串都匹配的结果。
split()	pattern, string	使用匹配的字符串，将原始字符串分割为串列。
findall()	pattern, string	找出全部匹配的字符串，返回为一个串列。
finditer()	pattern, string	找出全部匹配的字符串，返回为一个迭代器对象。
sub()	pattern, repl, string, count	从 string 找出全部匹配的字符串，并使用 repl 的字符串取代，count 默认 0 表示全部取代，设置次数可指定取代的个数。

import re

要使用 re 必须先 import re 模块，或使用 from 的方式，单独 import 特定的类型。

import re
from re import sample

compile(pattern)

re.compile(pattern) 可以 创建一个正则表达式的规则，规则创建后，就能使用 re 的其他方法执行套用这个规则的对象，举例来说，下方的代码执行后，会创建找寻“连续三个数字”的规则，接着使用 search 的方法，就能找到 123 这三个字符串 ( 下方会介绍跟 search 相关的方法 )。

配对的规则通常会用“r”进行标示，例如 r'str'。

import re
role = re.compile(r'\d\d\d')       # 连续三个数字
result = role.search('abc123xyz')  # 使用 search 方法，使用创建的规则，搜寻 abc123xyz
print(result.group())              # 123

re.compile(pattern) 还有第二个参数 flags，默认不需要填写，可以额外设置一些正则表达式的匹配方式，flags 有下列几种参数可供设置：

参数	说明
re.I	忽略字母大小写。
re.M	匹配“^”和“$”在开头和结尾时，会增加换行符之前和之后的位置。
re.S	使“.”完全匹配包括换行的任何字符，如果没有这个标签，“.”会匹配除了换行符外的任何字符。
re.X	当设置这个标签时，空白字符被忽略，除非该空白字符在字符类中或在反斜线之后，当一个行内有 # 不在字符集和转义序列，那么它之后的所有字符都是注释。
re.L	由当前语言区域决定 \w, \W, \b, \B 和大小写的匹配 ( 官方不建议使用，因为语言机制在不同作业系统可能会有不同 )。

下方的代码执行后，会找出 HeLlo 这个字 ( 不论字母大小写 )。

import re
role = re.compile(r'hello', flags=re.I)  # 匹配 hello，不论大小写
result = role.search('HeLlo World')
print(result.group())                    # HeLlo

使用 compile 后，包含 search，还有下列几种常用方法可以使用 ( 用法等同 re 的其他相关方法 )：

方法	参数	说明
search()	string	寻找第一个匹配的字符，如果没有匹配，返回 None。( 还可额外设置 pos 和 endpos，默认 0，可指定从第几个开始。
match()	string	从开头开始，寻找第一个匹配的字符。
fullmatch()	string	返回整个字符串都匹配的结果。
split()	string	使用匹配的字符串，将原始字符串分割为串列。
findall()	string	找出全部匹配的字符串，返回为一个串列。
finditer()	string	找出全部匹配的字符串，返回为一个迭代器对象。
sub()	repl, string, count	从 string 找出全部匹配的字符串，并使用 repl 的字符串取代，count 默认 0 表示全部取代，设置次数可指定取代的个数。

下方的代码执行后，会打印出搜寻后匹配的结果。

import re
role = re.compile(r'hello', flags=re.I)
result_search = role.search('HeLlo World, Hello oxxo')
result_match = role.match('HeLlo World, Hello oxxo')
result_fullmatch1 = role.fullmatch('HeLlo World, Hello oxxo')
result_fullmatch2 = role.fullmatch('HeLlo')
result_split = role.split('HeLlo World, Hello oxxo')
result_findall = role.findall('HeLlo World, Hello oxxo')
result_finditer = role.finditer('HeLlo World, Hello oxxo')
result_sub = role.sub('oxxo','HeLlo World, Hello oxxo')
print(result_search)          # <re.Match object; span=(0, 5), match='HeLlo'>
print(result_match)           # <re.Match object; span=(0, 5), match='HeLlo'>
print(result_fullmatch1)      # None
print(result_fullmatch2)      # <re.Match object; span=(0, 5), match='HeLlo'>
print(result_split)           # ['', ' World, ', ' oxxo']
print(result_findall)         # ['HeLlo', 'Hello']
print(list(result_finditer))  # [<re.Match object; span=(0, 5), match='HeLlo'>, <re.Match object; span=(13, 18), match='Hello'>]
print(result_sub)             # oxxo World, oxxo oxxo

进行正则表达式搜寻字符串内容后， 默认将匹配的数据分成同一组，也可在搜寻时使用“小括号”进行搜寻数据的“分组”，接着使用“group”或“groups”，将匹配到的数据内容取出。

下方的代码会分别显示有分组和没分组搜寻字符串的结果：

import re
role1 = re.compile(r'(hello) (world)', flags=re.I)
result_match1 = role1.match('HeLlo World, Hello oxxo')
print(result_match1)            # <re.Match object; span=(0, 11), match='HeLlo World'>
print(result_match1.span())     # (0, 11)
print(result_match1.groups())   # ('HeLlo', 'World')
print(result_match1.group(1))   # HeLlo
print(result_match1.group(2))   # World
role2 = re.compile(r'hello', flags=re.I)
result_match2 = role2.match('HeLlo World, Hello oxxo')
print(result_match2.groups())   # ()
print(result_match2.group())    # HeLlo
print(result_match2.group(1))   # 发生错误  no such group

由于使用 group 或 groups 时， 如果找不到 group 会发生错误 ( 没有匹配就没有 group )，所以可以 先使用 if 判断式先行筛选，避免错误情况发生，下方的代码执行后，会判断 result 是否为 None，如果是 None 就直接打打印出找不到数据的文字。

import re
role = re.compile(r'hello', flags=re.I)
result = role.fullmatch('HeLlo World, Hello oxxo')
if result == None:
    print('找不到数据')      # 没有匹配就打打印出找不到数据
else:
    print(result.group())  # 有匹配就打印出结果

search(pattern, string)

re.search(pattern, string) 使用后，会 寻找第一个匹配的字符，如果没有匹配，返回 None。( 还可额外设置 pos 和 endpos，默认 0，可指定从第几个开始，相关的操作等同于前一段 compile() 里介绍 的 search() 方法。下方代码会使用“忽略大小写”的匹配方式，搜寻并打印出 hello 字符串。

import re
text = 'HeLlo world, hello oxxo'
result = re.search(r'hello', text, flags=re.I)
print(result)            # <re.Match object; span=(0, 5), match='HeLlo'>
print(result.group())    # HeLlo

match(pattern, string)

re.match(pattern, string) 使用后，会 从开头开始，寻找第一个匹配的字符，相关的操作等同于前一段 compile() 里介绍 的 match() 方法。下方代码会使用“忽略大小写”的匹配方式，搜寻并打打印出 hello 字符串。

import re
text = 'HeLlo world, hello oxxo'
result = re.match(r'hello', text, flags=re.I)
print(result)            # <re.Match object; span=(0, 5), match='HeLlo'>
print(result.group())    # HeLlo

fullmatch(pattern, string)

re.fullmatch(pattern, string) 使用后，会 返回整个字符串都匹配的结果，相关的操作等同于前一段 compile() 里介绍 的 fullmatch() 方法。下方代码会使用“忽略大小写”的匹配方式，搜寻并打打印出 hello 字符串。

import re
text = 'HeLlo world, hello oxxo'
result = re.fullmatch(r'hello', text, flags=re.I)
print(result)            # None，因为没有全部都匹配
text2 = 'HeLlo'
result2 = re.fullmatch(r'hello', text2, flags=re.I)
print(result2)           # <re.Match object; span=(0, 5), match='HeLlo'>
print(result2.group())   # HeLlo

split(pattern, string)

re.split(pattern, string) 使用后，会 使用匹配的字符串，将原始字符串分割为串列，相关的操作等同于前一段 compile() 里介绍 的 split() 方法。下方代码会使用“忽略大小写”的匹配方式，将字符串用 hello 拆分成串列。

import re
text = 'HeLlo world, hello oxxo'
result = re.split(r'hello', text, flags=re.I)
print(result)     # ['', ' world, ', ' oxxo']

findall(pattern, string)

re.findall(pattern, string) 使用后，会 找出全部匹配的字符串，返回为一个串列，相关的操作等同于前一段 compile() 里介绍 的 findall() 方法。下方代码会使用“忽略大小写”的匹配方式，将搜寻到的 hello 全部取出变成串列。

import re
text = 'HeLlo world, hello oxxo'
result = re.findall(r'hello', text, flags=re.I)
print(result)     # ['HeLlo', 'hello']

finditer(pattern, string)

re.finditer(pattern, string) 使用后，会 找出全部匹配的字符串，返回为一个迭代器对象，相关的操作等同于前一段 compile() 里介绍 的 finditer() 方法。下方代码会使用“忽略大小写”的匹配方式，将搜寻到的 hello 全部取出变成迭代器对象。

import re
text = 'HeLlo world, hello oxxo'
result = re.finditer(r'hello', text, flags=re.I)
for i in result:
    print(i)
    print(i.group())
# <re.Match object; span=(0, 5), match='HeLlo'>
# HeLlo
# <re.Match object; span=(13, 18), match='hello'>
# hello

sub(pattern, repl, string, count)

re.sub(pattern, repl, string, count) 使用后，会 找从 string 找出全部匹配的字符串，并使用 repl 的字符串取代，count 默认 0 表示全部取代，设置次数可指定取代的个数，相关的操作等同于前一段 compile() 里介绍 的 sub() 方法。下方代码会使用“忽略大小写”的匹配方式，将搜寻到的 hello 全部置换成 oxxo。

import re
text = 'HeLlo world, hello oxxo'
result1 = re.sub(r'hello', 'oxxo', text, flags=re.I)
result2 = re.sub(r'hello', 'oxxo', text, count=1, flags=re.I)
print(result1)     # oxxo world, oxxo oxxo
print(result2)     # oxxo world, hello oxxo  ( count 设置 1 所以只换了一个 )