跳到主要内容

正则表达式：文本模式匹配

信息
2024年7月30日 · ·

引言​

正则表达式（Regular Expressions，简称 regex 或 regexp）是一种字符模式，用于匹配字符串中的子字符串。这些模式在编写搜索、替换和验证字符串的程序中非常强大和有用。本文将介绍正则表达式的基本语法和用法，并展示一些常见的处理方式。

基础语法​

正则表达式的基本构成部分包括原义字符和元字符。

  1. 原义字符

原义字符是指它们本身具有字面意义的字符，如 'a'，'1'，或者 '@'。

  1. 元字符

元字符在正则表达式中有特殊含义，如：

  • '.': 匹配除换行符以外的任意一个字符；
  • '^': 匹配字符串的开始；
  • '$': 匹配字符串的结束；
  • '*': 匹配前面的子表达式零次或多次；
  • '+': 匹配前面的子表达式一次或多次；
  • '?': 匹配前面的子表达式零次或一次；
  • '{n, m}': 匹配前面的子表达式至少 n 次，至多 m 次；
  • '[]': 定义字符集，匹配方括号内的任意字符；
  • '|': 逻辑或运算符，匹配左右任意一个表达式；
  • '()': 分组符，标记一个子表达式；

常见字符匹配​

下面示例，将展示常见的正则表达式匹配内容：

  1. 匹配特定字符
a    # 匹配字符 'a'
  1. 匹配任意一个字符
.    # 例如 a, 1, %
  1. 字符集
[abc]       # 匹配 'a', 'b' 或 'c'
[a-z]       # 匹配任意小写字母
[0-9]       # 匹配任意数字
[a-zA-Z0-9] # 匹配任意字母或数字
  1. 排除字符集
[^abc]     # 匹配除 'a', 'b', 'c' 以外的任何字符
  1. 特殊字符
\s         # 匹配任意空白字符
\S         # 匹配任意非空白字符
\d         # 匹配任意数字字符
\D         # 匹配任意非数字字符
\w         # 匹配任意字母、数字或下划线
\W         # 匹配任意非字母、非数字或非下划线字符

常见正则表达式​

以下是一些常见的正则表达式及其用途。

  1. 匹配电子邮件地址
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
  1. 匹配电话号码（简单示例）
^\d{10}$     # 匹配 10 位数字的电话号码
  1. 匹配 URL
^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)*\/?$
  1. 匹配日期（格式：yyyy-mm-dd）
^\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$

常见问题​

  1. 如何匹配回车符和换行符？

使用 '\r' 和 '\n' 匹配回车符和换行符，或使用 '[\r\n]' 组合匹配：

\r        # 匹配回车符
\n        # 匹配换行符
[\r\n]    # 匹配回车符或换行符
  1. 如何表示重复次数？

使用 '{n, m}' 语法来表示重复次数：

a{3}          # 匹配 'aaa'
a{1,3}        # 匹配 'a' 或 'aa' 或 'aaa'
a{3,}         # 匹配至少三个 'a'
  1. 如何在正则表达式中使用特殊字符？

使用 '' 来转义特殊字符：

\*        # 匹配字符 '*'
\+        # 匹配字符 '+'

非贪婪匹配​

正则表达式默认是“贪婪”的，会尽可能多地匹配字符。非贪婪匹配（或惰性匹配）则尽可能少地匹配字符。通过在量词后面添加 '?' 实现非贪婪匹配。

  1. 贪婪匹配
<a.*>  # 匹配 <a> 和 <a>内容</a> 中的 <a>内容</a>
  1. 非贪婪匹配
<a.*?>  # 匹配 <a> 和 <a>内容</a> 中的 <a>

Python 演练​

Python 提供 re 模块，用于处理正则表达式。以下示例将展示一些基本用法。

  1. 导入模块
import re
  1. 基本匹配
pattern = r'\d+'  # 匹配一个或多个数字
text = '123 abc 456'
matches = re.findall(pattern, text)
print(matches)  # 输出: ['123', '456']
  1. 分组匹配
pattern = r'(\d+)-(\d+)-(\d+)'  # 匹配日期格式 yyyy-mm-dd
text = '2023-10-11'
matches = re.match(pattern, text)
if matches:
    print(matches.groups())  # 输出: ('2023', '10', '11')
  1. 替换字符串
pattern = r'\d+'  # 匹配一个或多个数字
text = 'abc123def456'
new_text = re.sub(pattern, '#', text)
print(new_text)  # 输出: 'abc#def#'
  1. 编译和重用正则表达式
pattern = re.compile(r'\d{4}-\d{2}-\d{2}')  # 编译正则表达式
text = '2023-10-11'
if pattern.match(text):
    print('匹配成功')

灾难性回溯​

灾难性回溯（Catastrophic Backtracking）是在一些复杂或次优的正则表达式中发生的，导致匹配耗时极长甚至系统崩溃。例如：

问题示例

^(a|a?)*$ # 在处理长字符串时，可能导致灾难性回溯

若匹配字符串 aaaaaa（包含多个 a），上述表达式会尝试大量无效匹配组合，导致性能问题。

解决办法

  1. 优化正则表达式，避免使用容易导致回溯的模式，如 (a|a?)*，可以简化为 a*。
^a*$   # 简化后的表达式
  1. 使用“非回溯”正则引擎，某些编程语言或库提供了优化或“非回溯”的正则引擎，可以有效避免灾难性回溯的问题。

通过了解并善加利用这些技巧和优化，可以大大提高正则表达式的性能和可靠性。

结语​

正则表达式是一种强大且灵活的工具，用于文本处理和模式匹配。理解其语法和常见用法能够提高处理字符串数据的效率和准确性。本文对正则表达式的基础知识、非贪婪匹配、Python 中的用法以及灾难性回溯问题做了详细介绍，希望能够帮助你更好地掌握和应用正则表达式助。

细心使用正则表达式，并避免潜在的性能问题，将助你在实际编程中更好地解决文本处理任务。