高效使用正则表达式处理数字数据：从基础到精通

引言：数字数据无处不在，正则处理大有可为

在信息时代，我们被海量的数据所包围，而其中相当一部分是以数字形式存在的。无论是科学计算、金融交易、日志分析、网页抓取还是简单的文本编辑，数字数据都扮演着至关重要的角色。如何有效地从复杂的文本中提取、验证、转换和操纵这些数字，成为了一项基本而关键的技能。

正则表达式（Regular Expression, Regex），作为一种描述字符模式的强大语言，为处理文本数据提供了无与伦比的灵活性和精确性。虽然正则表达式通常被认为主要用于处理字符串，但它在处理嵌入文本中的数字数据时同样表现出色，甚至可以说是不可或缺的工具。然而，“能用”和“用好”之间存在着巨大的鸿沟。一个低效、模糊的正则表达式不仅可能导致性能瓶颈，还可能产生错误的结果。

本文旨在深入探讨如何高效地使用正则表达式来处理数字数据。我们将从基础的数字模式构建开始，逐步深入到更复杂的场景，如处理带分隔符的数字、特定格式（货币、科学计数法）以及性能优化技巧，最终帮助读者掌握在各种场景下精确、高效地运用正则表达式处理数字数据的能力。

第一部分：正则表达式与数字数据的邂逅

1.1 正则表达式基础回顾

在深入数字处理之前，我们先简单回顾一下正则表达式的核心概念：

元字符 (Metacharacters): 具有特殊含义的字符，如 . (匹配任意单个字符，换行符除外), * (匹配前一个元素零次或多次), + (匹配前一个元素一次或多次), ? (匹配前一个元素零次或一次), [] (定义字符集), () (分组), | (或逻辑), ^ (匹配字符串开头), $ (匹配字符串结尾), \ (转义字符)。
字符类 (Character Classes): 如 \d (匹配任意数字，等价于 [0-9]), \s (匹配任意空白字符), \w (匹配字母、数字或下划线)。
量词 (Quantifiers): 控制匹配次数，如 {n} (恰好 n 次), {n,} (至少 n 次), {n,m} (n 到 m 次)。默认是贪婪匹配 (Greedy)。
边界匹配 (Anchors and Boundaries): 如 ^, $, \b (匹配单词边界)。

理解这些基础是构建任何有效正则表达式的前提。

1.2 为何选择正则表达式处理数字？

你可能会问，许多编程语言本身就提供了强大的数字处理函数（如类型转换、数学运算），为何还需要正则表达式？原因在于：

灵活性与模式匹配: 数字往往嵌入在非结构化的文本中。正则表达式可以精确地定位和提取符合特定模式的数字，无论它们周围是什么字符。例如，从 “订单号 OD12345 价格 $99.99” 中提取价格。
验证复杂格式: 数字格式可能多种多样，如整数、小数、负数、科学计数法、带千位分隔符的数字、特定小数位数的货币等。正则表达式可以轻松定义这些复杂规则进行验证。
数据清洗与转换: 在数据预处理阶段，经常需要清理或统一数字格式（如去除货币符号、逗号，标准化小数位）。正则表达式的查找和替换功能非常适合此类任务。
通用性: 正则表达式是跨语言、跨平台的标准（虽然存在细微方言差异），掌握后可在多种环境（Python, Java, JavaScript, Perl, grep, sed 等）中应用。

第二部分：构建基础数字模式

掌握基础数字模式的构建是高效处理数字数据的第一步。

2.1 匹配整数 (Integers)

最简单的数字形式是整数。

基础整数: \d+
- \d 匹配一个数字。
- + 表示匹配一次或多次。
- 这个模式会匹配如 1, 123, 0, 007 等。
排除前导零 (非零开头的整数): [1-9]\d*
- [1-9] 匹配一个非零数字。
- \d* 匹配零个或多个数字。
- 这个模式匹配 1, 123, 9，但不匹配 0 或 07。
匹配包含零的整数 (标准形式): 0|[1-9]\d*
- 0 直接匹配数字 0。
- | 表示“或”。
- 这个模式能正确匹配 0 以及所有非零开头的正整数。
匹配正负整数: -?\d+
- -? 匹配零次或一次负号。
- \d+ 匹配至少一个数字。
- 这个模式会匹配 123, -45, 0, 但也可能匹配 -0（如果需要精确，可能要进一步细化）。
- 更精确的匹配（不允许 -0，允许 0）： 0|(-?[1-9]\d*)
结合边界进行精确验证: 如果要验证一个字符串完全是一个整数，需要使用锚点 ^ 和 $。
- 验证标准整数: ^([1-9]\d*|0)$
- 验证包含正负的整数: ^(-?[1-9]\d*|0)$

2.2 匹配小数/浮点数 (Decimals / Floating-Point Numbers)

小数的模式比整数复杂一些，需要考虑小数点 .。

基础小数 (必须有整数和小数部分): \d+\.\d+
- \d+ 匹配整数部分（至少一位）。
- \. 匹配小数点（注意 . 是元字符，需要转义）。
- \d+ 匹配小数部分（至少一位）。
- 匹配 12.34, 0.5。
可选整数部分: \d*\.\d+
- \d* 允许整数部分为零个或多个数字。
- 匹配 .5, 0.5, 12.34。
可选小数部分: \d+\.\d*
- \d* 允许小数部分为零个或多个数字。
- 匹配 12., 12.34, 5.。
整数或小数 (通用数字形式): \d+(\.\d+)?
- (\.\d+)? 将小数点和小数部分作为一个可选组。
- 匹配 123, 12.34。
更通用的形式 (允许 .5 或 5.): \d*\.?\d+ (注意这个模式可能匹配 .，需要结合上下文或进一步细化)
- 一个更健壮的模式，需要至少包含一个数字: (\d+\.?\d*|\.\d+)
  - \d+\.?\d* 匹配 123, 12., 12.34
  - |\.\d+ 或，匹配 .5, .678
- 这个模式确保了至少有一个数字出现。
包含正负号: 在上述模式前加上 -?。
- 例如，匹配正负小数或整数： -?(\d+\.?\d*|\.\d+)
结合边界进行验证:
- 验证标准浮点数: ^-?(\d+\.\d+)$
- 验证通用数字（整数或小数）: ^-?(\d+(\.\d+)?)$
- 验证更宽泛的数字（含 .5, 5.）: ^-?(\d+\.?\d*|\.\d+)$

2.3 匹配科学计数法 (Scientific Notation)

科学计数法，如 1.23e+10 或 -9.8E-5。

基础模式: [-+]?\d*\.?\d+([eE][-+]?\d+)
- [-+]? 可选的正负号。
- \d*\.?\d+ 匹配尾数部分（可以是整数或小数，参考前面）。这里使用 \d*\.?\d+ 是为了涵盖 .5e10 这样的形式，但更常见的是要求尾数至少有一位整数部分 \d+\.?\d* 或标准小数 \d+\.\d+。我们选用一个相对通用的 \d*\.?\d+ 并假定其至少匹配到一个数字。
- ([eE][-+]?\d+) 匹配指数部分：
  - [eE] 匹配指数符号 ‘e’ 或 ‘E’。
  - [-+]? 可选的指数正负号。
  - \d+ 匹配指数值（至少一位数字）。
结合边界验证: ^[-+]?\d*\.?\d+([eE][-+]?\d+)$

重要提示： 构建基础模式时，务必考虑：
* 精确性: 模式是否只匹配你想要的数字格式？是否会误匹配其他内容？
* 完整性: 模式是否涵盖了所有你需要处理的合法数字格式？
* 边界: 是否需要使用 ^, $, \b 来确保匹配的是整个字符串、整个单词，还是仅仅是文本中的一部分？\b 对于从文本中提取独立的数字特别有用，例如 \b\d+\b 可以匹配 “file123” 中的 “123”，但不会匹配 “123file” 中的 “123”（除非后面有空格或标点）。

第三部分：进阶模式与特定格式处理

现实世界中的数字数据往往更加复杂。

3.1 处理带千位分隔符的数字

如 1,000,000 或 12,345.67。这是正则表达式处理的一个难点，因为分隔符的位置依赖于数字的长度。

基础模式 (仅整数部分带逗号): \d{1,3}(?:,\d{3})*
- \d{1,3} 匹配第一组数字（1到3位）。
- (?:,\d{3})* 匹配零个或多个“逗号 + 三位数字”的组合。
  - (?:...) 是非捕获组 (Non-capturing group)，表示我们只需要这个分组用于量词 *，但不需要单独提取这部分内容。这有助于提升效率。
- 这个模式能匹配 1, 123, 1,000, 12,345, 123,456。
结合小数部分: \d{1,3}(?:,\d{3})*(?:\.\d+)?
- (?:\.\d+)? 添加了可选的小数部分（同样使用非捕获组）。
- 匹配 1,234.56, 123, 1,000。
处理负数和边界: ^-?\d{1,3}(?:,\d{3})*(?:\.\d+)?$
- 用于验证一个字符串是否是带有标准千位分隔符的数字。
更严格的模式 (避免前导零，除非是数字 0):
- 整数部分: (0|[1-9]\d{0,2}(?:,\d{3})*)
  - 0 直接匹配 0。
  - | 或
  - [1-9]\d{0,2} 匹配第一组（1-999），不允许前导零。
  - (?:,\d{3})* 匹配后续的逗号分隔组。
- 完整验证模式: ^(-?(?:0|[1-9]\d{0,2}(?:,\d{3})*))(?:\.\d+)?$

注意: 这个模式假设逗号总是精确地每三位出现一次。对于不规范的数据（如 1,23,456），它可能无法正确匹配或验证。

3.2 匹配特定范围的数字

正则表达式本身不擅长处理复杂的数值范围（例如，匹配 1 到 255 之间的数字）。虽然可以通过复杂的模式实现（尤其是小范围），但这通常非常繁琐且效率低下。

简单范围示例 (0-99): \b([0-9]|[1-9][0-9])\b
- [0-9] 匹配 0 到 9。
- | 或
- [1-9][0-9] 匹配 10 到 99。
- \b 确保匹配的是独立的数字。
中等范围示例 (0-255): \b([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\b
- [0-9]: 0-9
- [1-9][0-9]: 10-99
- 1[0-9]{2}: 100-199
- 2[0-4][0-9]: 200-249
- 25[0-5]: 250-255
- 可见，随着范围增大，模式迅速变得复杂。

高效策略: 对于复杂的数值范围检查，最佳实践通常是：
1. 使用一个相对宽松的正则表达式（如 \b\d+\b）提取所有潜在的数字。
2. 在编程语言中将提取到的字符串转换为数字类型。
3. 使用编程语言的比较运算符进行范围检查 (if num >= min_val and num <= max_val)。
这种方法通常更清晰、更易于维护，并且性能更好。

3.3 处理特定格式：货币、百分比等

货币格式 (示例: $1,234.56 或 €99.99):
- ([$€£])\s*-?\d{1,3}(?:,\d{3})*(?:\.\d{1,2})?
  - ([$€£]) 捕获货币符号（美元、欧元、英镑）。可以扩展 [] 加入更多符号。
  - \s* 匹配可选的空格。
  - -? 可选负号。
  - \d{1,3}(?:,\d{3})* 处理带逗号的整数部分。
  - (?:\.\d{1,2})? 可选的小数部分，限制为 1 或 2 位小数。
- 根据具体需求调整符号位置、是否强制小数位、是否允许负数等。
百分比格式 (示例: 75% 或 99.5%):
- -?(\d+(\.\d+)?)%
  - -? 可选负号。
  - (\d+(\.\d+)?) 匹配整数或小数。
  - % 匹配百分号。
- 使用边界： \b-?(\d+(\.\d+)?)%\b

3.4 从混合文本中提取数字

这是正则表达式的强项。使用捕获组 () 来提取所需的部分。

提取所有数字 (整数或小数): (-?(\d+(\.\d+)?))
- 外层括号 () 用于捕获整个匹配到的数字。
- 内层 (\.\d+)? 是可选的小数部分，如果需要区分整数和小数，可以分析捕获组。
提取特定上下文的数字: 假设要从 “ID: 123, Value: 45.67” 中提取 Value。
- Value:\s*(-?(\d+(\.\d+)?))
  - Value:\s* 匹配字面量 “Value:” 和后面的任意空格。
  - (-?(\d+(\.\d+)?)) 捕获紧随其后的数字。
  - 通常我们只关心第一个捕获组（整个数字）。

示例代码 (Python):
“`python
import re

text = “Item A costs $19.99, Item B is -25.00 EUR. Count: 1,000 units. Rate: 85.5%.”
pattern = r’-?(\d{1,3}(?:,\d{3})*(.\d+)?|\d+(.\d+)?)’ # 匹配整数、小数、带逗号的数

numbers_found = re.findall(pattern, text)

findall 返回的是元组列表，因为有捕获组。我们需要处理一下

extracted_numbers = [match[0] for match in numbers_found]

match[0] 是整个匹配到的字符串，如 ‘19.99’, ‘-25.00’, ‘1,000’, ‘85.5’

print(extracted_numbers)

Output: [‘19.99’, ‘-25.00’, ‘1,000’, ‘85.5’]

注意：这个模式可能不够完美，例如 85.5% 中的 85.5 被提取，可能需要更精确的上下文。

“`

第四部分：效率优化：让正则快如闪电

写出能工作的正则表达式是一回事，写出高效的正则表达式是另一回事。尤其是在处理大数据量时，低效的正则可能成为性能瓶颈。

4.1 精确性原则 (Be Specific)

使用最具体的字符类: 用 \d 而不是 . 来匹配数字；用 [a-z] 而不是 . 来匹配小写字母。. 会尝试匹配任何字符，增加了引擎的工作量。
避免过度使用 . 和 */+: 贪婪的 .* 或 .+ 可能会匹配超出预期的内容，并导致引擎进行大量回溯（见下文）。如果可能，使用更具体的模式或非贪婪量词 *?/+?。

4.2 警惕灾难性回溯 (Catastrophic Backtracking)

这是正则表达式性能问题的最常见原因之一。当一个模式包含嵌套的、重复的、且可能匹配相同文本的量词时，正则表达式引擎可能会陷入指数级的尝试路径，消耗大量时间和内存。

典型例子: (a+)+ 或 (a*)* 应用于长字符串 aaaaaaaa...b。
数字处理中的可能场景: 虽然纯数字模式相对不容易触发，但在复杂的模式中（如解析带嵌套结构的文本，其中包含数字）或不小心写出的模式中（如 (\d+,?)+ 尝试匹配逗号分隔的数字，但这写法很危险）可能出现。
如何避免:
- 避免嵌套重复量词: 重新设计模式。
- 使内部匹配更具体: 让内层和外层的量词匹配不同的内容。
- 使用非捕获组 (?:...): 虽然它本身不直接解决回溯，但清晰的结构有助于发现问题。
- 使用原子组 (?>...) 或占有量词 *+, ++, ?+ (如果引擎支持): 这些特性可以阻止引擎在匹配失败时回溯到组内或量词内部，一旦匹配成功就“占有”该部分，不再交还。

示例 (占有量词): 假设有一个（可能不规范的）逗号分隔列表，我们想匹配数字段。
* \d++(?:,\d++)* （使用占有量词 ++）
* \d++ 会尽可能多地匹配数字，并且不回溯。如果后面需要逗号但当前位置不是逗号，它不会为了满足后续的 , 而减少 \d 的匹配数量。这在某些情况下可以极大提高效率，但也可能改变匹配行为（可能导致原本能匹配的模式失败）。

4.3 使用非捕获组 (Non-Capturing Groups)

(...) vs (?:...):
- (...) (捕获组): 引擎会匹配该组的内容，并将其存储起来以便后续引用（如反向引用 \1）或提取。这需要额外的内存和时间。
- (?:...) (非捕获组): 引擎仅用其进行分组（例如，应用量词 *, +, ? 或 |），但不存储匹配结果。
优化原则: 如果你仅仅需要分组来实现逻辑（如 (jpg|png|gif) 或 (\.\d+)?），而不需要稍后提取或引用这个组的内容，始终使用非捕获组 (?:...)。这可以减少内存消耗，略微提高性能。

4.4 字符组优于或运算 (Character Classes vs Alternation)

[abc] vs (a|b|c): 匹配单个字符时，字符组 [...] 通常比使用 | 的分组更高效。引擎处理字符组通常有优化。
对于数字: [0-9] （或等效的 \d）远优于 (0|1|2|3|4|5|6|7|8|9)。虽然没人会这么写后者，但这个原则适用于其他字符集。

4.5 理解你的正则引擎 (Know Your Engine)

不同的正则表达式引擎（PCRE, Python re, Java java.util.regex, JavaScript, .NET 等）在实现细节、支持的特性（如原子组、占有量词、后向断言等）以及优化策略上可能存在差异。
* 了解你所使用的环境的引擎特性。
* 查阅文档，了解是否有特定的性能建议或陷阱。

4.6 预编译正则表达式 (Pre-compile Regular Expressions)

如果在程序中（如 Python, Java, C#）需要在一个循环或函数中反复使用同一个正则表达式，强烈建议先将其编译。

Python 示例:
“`python
import re

编译一次

number_pattern = re.compile(r’\b\d+.\d+\b’)

data_lines = [“Log entry 1: value 12.34”, “Log entry 2: value 56.78”, …]

for line in data_lines:
# 重复使用已编译的模式
match = number_pattern.search(line)
if match:
print(f”Found float: {match.group(0)}”)
“`
* 编译操作本身有开销，但对于重复使用，这个开销会被摊销，后续的匹配操作会更快，因为模式已经被解析和优化。

第五部分：实战演练与常见陷阱

让我们通过几个场景巩固一下：

场景 1: 验证输入是否为有效的美国邮政编码 (5位或9位数字)
* 模式: ^\d{5}(?:-\d{4})?$
* ^: 字符串开头。
* \d{5}: 匹配 5 位数字。
* (?:-\d{4})?: 可选的非捕获组，匹配一个连字符和 4 位数字。
* $: 字符串结尾。
* 效率考量：使用了非捕获组，模式精确，没有明显的回溯风险。

场景 2: 从一段文本中提取所有看起来像货币的数值 (允许 $ 或 € 开头，带逗号，最多两位小数)
* 模式: \b[$€]\s*\d{1,3}(?:,\d{3})*(?:\.\d{1,2})?\b
* \b: 单词边界，避免匹配如 “US$123” 中的 “S$123″。
* [$€]: 匹配美元或欧元符号。
* \s*: 可选空格。
* \d{1,3}(?:,\d{3})*: 处理带逗号的整数部分。
* (?:\.\d{1,2})?: 可选的 1-2 位小数部分。
* \b: 单词边界。
* 效率考量：使用了非捕获组。模式相对复杂，但在典型文本长度下性能应该可以接受。如果数据量巨大且性能敏感，需测试。

场景 3: 清理数据，将所有数字中的逗号移除 (如 “1,234,567.89” -> “1234567.89”)
* 这通常用编程语言的替换功能结合正则查找来实现。
* 查找模式: (\d),(\d{3})
* 查找数字后面紧跟着逗号和三位数字的情况。捕获逗号前后的数字部分。
* 替换逻辑 (伪代码):
while pattern.find(text): text = pattern.replace(text, r"\1\2") # 用捕获组1和捕获组2替换掉匹配内容（含逗号）
* Python re.sub 可以更简洁地完成：
“`python
text = “Value is 1,234,567.89 dollars”
# 使用循环或更智能的正则确保所有逗号被移除
# 一个简单（但可能需要多次调用或更复杂正则）的方法：
cleaned_text = re.sub(r'(\d),(\d)’, r’\1\2′, text)
# 注意：简单的 re.sub 可能只替换第一个。需要确保能处理多个逗号。
# 更健壮的方式可能是先找到数字，再处理字符串。

  # 更可靠的方式：找到完整数字，然后在该数字内部替换逗号
  def remove_commas_in_number(match):
      number_str = match.group(0)
      return number_str.replace(',', '')

  number_with_commas_pattern = re.compile(r'\b\d{1,3}(?:,\d{3})*(?:\.\d+)?\b')
  cleaned_text = number_with_commas_pattern.sub(remove_commas_in_number, text)
  print(cleaned_text) # Output: Value is 1234567.89 dollars
  ```

效率考量：替换操作可能涉及多次查找和字符串重建，对于非常大的文本，需要关注性能。使用编译后的正则和高效的替换策略很重要。

常见陷阱:
* 过度贪婪: .* 或 \d+ 匹配了不期望的内容。
* 边界问题: 忘记使用 ^, $, \b 导致部分匹配或错误匹配。
* 转义: 忘记转义特殊字符，尤其是 .。
* 浮点数精度: 正则表达式本身不处理浮点数的精度问题，提取后在编程语言中处理。
* 国际化: 不同地区的数字格式（如小数点用逗号，千位分隔符用点）需要调整模式。

第六部分：何时不使用正则表达式？

尽管正则表达式非常强大，但并非所有数字处理任务都适合用它。

简单的类型转换和算术运算: 如果你已经有了一个干净的数字字符串（如 “123”），直接用编程语言的函数（int(), float()）转换并进行计算，通常比用正则更简单、更高效。
极其复杂的范围或逻辑验证: 如前所述，复杂的数值范围检查用编程逻辑更优。
解析高度结构化的数据格式: 对于 JSON, XML, CSV 等格式，使用专门的解析库通常更健स्टेंट、更易维护，也可能更高效。正则表达式可以作为辅助工具，但不应作为主要的解析手段。
性能极其敏感的核心循环: 如果在每秒需要处理数百万次操作的核心计算循环中进行简单的数字查找或验证，即使是编译后的正则也可能有性能开销。此时应考虑更底层的字符串操作或专门优化的算法。

结论：精通正则，驾驭数字

正则表达式是处理文本中数字数据的强大武器。从基础的整数、小数匹配，到处理复杂的带分隔符格式、科学计数法，再到从非结构化文本中精确提取，正则表达式都能提供灵活而有效的解决方案。

然而，高效使用正则表达式不仅仅是写出能匹配的模式，更在于理解其工作原理，关注精确性、完整性、边界和性能。通过采用具体化模式、避免灾难性回溯、善用非捕获组、预编译模式等优化技巧，我们可以显著提升处理效率，尤其是在面对大规模数据时。

同时，也要认识到正则表达式的局限性，明智地选择何时使用它，何时结合编程语言的特性或其他工具，以达到最佳的处理效果。

掌握高效的正则表达式数字处理技术，将使你在数据清洗、分析、验证和自动化等众多领域如虎添翼，更自如地驾驭数字世界。不断实践、测试和优化，你终将成为正则表达式处理数字数据的高手。

高效使用正则表达式处理数字数据 – wiki基地

高效使用正则表达式处理数字数据：从基础到精通

引言：数字数据无处不在，正则处理大有可为

第一部分：正则表达式与数字数据的邂逅

1.1 正则表达式基础回顾

1.2 为何选择正则表达式处理数字？

第二部分：构建基础数字模式

2.1 匹配整数 (Integers)

2.2 匹配小数/浮点数 (Decimals / Floating-Point Numbers)

2.3 匹配科学计数法 (Scientific Notation)

第三部分：进阶模式与特定格式处理

3.1 处理带千位分隔符的数字

3.2 匹配特定范围的数字

3.3 处理特定格式：货币、百分比等

3.4 从混合文本中提取数字

findall 返回的是元组列表，因为有捕获组。我们需要处理一下

match[0] 是整个匹配到的字符串，如 ‘19.99’, ‘-25.00’, ‘1,000’, ‘85.5’

Output: [‘19.99’, ‘-25.00’, ‘1,000’, ‘85.5’]

注意：这个模式可能不够完美，例如 85.5% 中的 85.5 被提取，可能需要更精确的上下文。

第四部分：效率优化：让正则快如闪电

4.1 精确性原则 (Be Specific)

4.2 警惕灾难性回溯 (Catastrophic Backtracking)

4.3 使用非捕获组 (Non-Capturing Groups)

4.4 字符组优于或运算 (Character Classes vs Alternation)

4.5 理解你的正则引擎 (Know Your Engine)

4.6 预编译正则表达式 (Pre-compile Regular Expressions)

编译一次

第五部分：实战演练与常见陷阱

第六部分：何时不使用正则表达式？

结论：精通正则，驾驭数字

发表评论取消回复

高效使用正则表达式处理数字数据：从基础到精通

引言：数字数据无处不在，正则处理大有可为

第一部分：正则表达式与数字数据的邂逅

1.1 正则表达式基础回顾

1.2 为何选择正则表达式处理数字？

第二部分：构建基础数字模式

2.1 匹配整数 (Integers)

2.2 匹配小数/浮点数 (Decimals / Floating-Point Numbers)

2.3 匹配科学计数法 (Scientific Notation)

第三部分：进阶模式与特定格式处理

3.1 处理带千位分隔符的数字

3.2 匹配特定范围的数字

3.3 处理特定格式：货币、百分比等

3.4 从混合文本中提取数字

findall 返回的是元组列表，因为有捕获组。我们需要处理一下

match[0] 是整个匹配到的字符串，如 ‘19.99’, ‘-25.00’, ‘1,000’, ‘85.5’

Output: [‘19.99’, ‘-25.00’, ‘1,000’, ‘85.5’]

注意：这个模式可能不够完美，例如 85.5% 中的 85.5 被提取，可能需要更精确的上下文。

第四部分：效率优化：让正则快如闪电

4.1 精确性原则 (Be Specific)

4.2 警惕灾难性回溯 (Catastrophic Backtracking)

4.3 使用非捕获组 (Non-Capturing Groups)

4.4 字符组优于或运算 (Character Classes vs Alternation)

4.5 理解你的正则引擎 (Know Your Engine)

4.6 预编译正则表达式 (Pre-compile Regular Expressions)

编译一次

第五部分：实战演练与常见陷阱

第六部分：何时不使用正则表达式？

结论：精通正则，驾驭数字

发表评论 取消回复

发表评论取消回复