Python数字与文字数字提取技巧

1. 理解挑战：数字与文字数字的混合识别

在文本处理中，我们经常需要从字符串中提取数字。然而，当数字以两种形式出现时——即阿拉伯数字（如 1, 2）和英文拼写形式（如 one, two）——问题变得复杂。更具挑战性的是，这些拼写形式的数字可能与其他字符混合，甚至出现重叠，例如在 "eightwothree" 中，我们期望识别出 '8' 和 '3'，而在 "xtwone3four" 中，'two' 和 'one' 紧密相连，需要分别识别为 '2' 和 '1'。

示例问题： 考虑以下输入字符串及其期望的输出：

• two1nine => 29
• eightwothree => 83
• abcone2threexyz => 13
• xtwone3four => 24
• 4nineeightseven2 => 42
• zoneight234 => 14
• 7pqrstsixteen => 76

传统字符串替换方法的局限性： 初学者可能会尝试使用 str.replace() 方法将所有拼写数字替换为阿拉伯数字。例如：

tmp_string = line.strip()
tmp_string = tmp_string.replace("nine", "9")
tmp_string = tmp_string.replace("eight", "8")
# ...
tmp_string = tmp_string.replace("one", "1")

这种方法存在明显缺陷：

1. 顺序问题： 如果替换顺序不当，可能会导致错误。例如，如果先替换 "one"，再替换 "twone" 中的 "two"，那么 "twone" 可能变成 "t2ne"，丢失了 "one"。
2. 重叠问题： 对于 "eightwothree" 这样的字符串，如果先将 "eight" 替换为 "8"，得到 "8wothree"，那么 "two" 和 "three" 仍然存在，但 "two" 在 "eight" 之后，"three" 在 "two" 之后，简单的替换无法处理这种重叠或相邻的上下文。更典型的重叠是 "twone"，它包含 "two" 和 "one"。简单的替换通常会破坏其中一个。

为了解决这些问题，我们需要更精细的文本解析策略。

2. 方案一：基于正则表达式的精确匹配

正则表达式（Regex）是处理字符串模式匹配的强大工具。通过巧妙地构造正则表达式，我们可以同时匹配阿拉伯数字和拼写数字，并处理重叠情况。

核心概念：

• \d: 匹配任何阿拉伯数字（0-9）。
• |: 逻辑或运算符，允许匹配多个模式中的任意一个。
• 零宽先行断言 (?=...): 这是解决重叠匹配的关键。它允许正则表达式引擎在不消耗字符的情况下进行匹配。例如，(?=(two|one)) 会在找到 "two" 或 "one" 的位置时返回匹配，但光标不会移动到匹配内容的末尾，从而允许后续的匹配从同一位置或紧邻位置开始。

实现步骤：

1. 定义映射关系： 创建一个字典，将拼写数字映射到其对应的阿拉伯数字。
2. 构建正则表达式： 结合 \d 和所有拼写数字，并使用零宽先行断言 (?=...) 将它们包裹起来。
3. 查找所有匹配： 使用 re.findall() 查找字符串中所有符合模式的匹配项。
4. 转换并提取首尾： 遍历匹配结果，将拼写数字转换为阿拉伯数字，然后提取转换后的第一个和最后一个数字。

代码示例：extract_calibration_value 函数

import re

def extract_calibration_value(line: str) -> int:
    """
    从字符串中提取第一个和最后一个数字（阿拉伯数字或拼写数字），
    并将其组合成一个两位数。
    能够处理重叠的拼写数字。
    """
    # 建立拼写数字到阿拉伯数字的映射
    word_to_digit = {
        'one': '1', 'two': '2', 'three': '3', 'four': '4',
        'five': '5', 'six': '6', 'seven': '7', 'eight': '8', 'nine': '9'
    }

    # 构建正则表达式模式。
    # (?=...) 是一个正向先行断言，它允许匹配重叠的模式。
    # 例如，对于 "twone"，(?=(\d|two|one)) 可以匹配到 "two" 和 "one"。
    # 我们捕获实际的匹配内容在第1组中。
    pattern = r'(?=(\d|one|two|three|four|five|six|seven|eight|nine))'

    # 查找所有匹配项，不区分大小写
    matches = re.findall(pattern, line.lower())

    if not matches:
        # 如果没有找到任何数字，根据需求返回0或抛出异常
        return 0

    # 将匹配到的单词转换为数字
    converted_digits = []
    for match in matches:
        if match.isdigit():
            converted_digits.append(match)
        else:
            converted_digits.append(word_to_digit[match])

    # 提取第一个和最后一个转换后的数字
    first_digit = int(converted_digits[0])
    last_digit = int(converted_digits[-1])

    # 组合成两位数
    return first_digit * 10 + last_digit

# 示例测试
test_lines = [
    "two1nine",
    "eightwothree",
    "abcone2threexyz",
    "xtwone3four",
    "4nineeightseven2",
    "zoneight234",
    "7pqrstsixteen"
]

print("--- 正则表达式方案测试 ---")
for i, line in enumerate(test_lines):
    value = extract_calibration_value(line)
    print(f"  Line {i+1}: '{line}' -> {value}")

代码逻辑解释：

• word_to_digit 字典提供了快速查找拼写数字对应阿拉伯数字的能力。
• pattern = r'(?=(\d|one|two|three|four|five|six|seven|eight|nine))' 是核心。
  • \d 匹配单个阿拉伯数字。
  • one|two|...|nine 匹配任何一个拼写数字。
  • (...) 创建一个捕获组，使得 re.findall 返回匹配到的具体内容。
  • (?=...) 是一个正向先行断言。它使得模式匹配成功后，正则表达式引擎的当前位置不会向前推进。这意味着即使 "twone" 中的 "two" 被匹配到，引擎仍然可以从 'w' 之后的位置开始寻找下一个匹配，从而找到 "one"。
• re.findall(pattern, line.lower()) 会返回一个列表，其中包含所有捕获组的匹配内容。例如，对于 "xtwone3four"，它可能返回 ['two', 'one', '3', 'four']。
• 遍历 matches 列表，将拼写数字通过 word_to_digit 字典转换为阿拉伯数字字符串，并将阿拉伯数字直接添加。
• 最终，取 converted_digits 列表的第一个元素和最后一个元素，转换为整数，并组合成最终的两位数。

3. 方案二：使用 word2number 库进行整体转换

虽然上述正则表达式方法是解决特定问题（混合数字的精确提取）的有效方案，但Python生态系统中也存在专门用于将英文数字词语转换为数字的库，例如 word2number。这个库适用于将完整的英文数字短语（如 "eighty three" 或 "one hundred twenty-three"）转换为其数值。

word2number 库介绍：word2number 是一个简洁的库，能够将用英文单词表示的数字转换为整数或浮点数。

安装：

pip install word2number

代码示例：words_to_digits 函数

from word2number import w2n

def words_to_digits(value: str):
    """
    使用 word2number 库将完整的英文数字短语转换为数值。
    """
    try:
        number = w2n.word_to_num(value)
        return number
    except ValueError:
        return None

print("\n--- word2number 库示例 ---")
# 示例：转换完整的数字短语
print(f"'eighty three' -> {words_to_digits('eighty three')}") # 输出: 83
print(f"'one hundred twenty-three' -> {words_to_digits('one hundred twenty-three')}") # 输出: 123
print(f"'seven' -> {words_to_digits('seven')}") # 输出: 7

# 尝试转换非完整数字短语，会失败
print(f"'eightwothree' -> {words_to_digits('eightwothree')}") # 输出: None (或抛出异常，取决于具体版本)
print(f"'two1nine' -> {words_to_digits('two1nine')}") # 输出: None

重要提示：word2number 在本特定问题中的局限性word2number 库非常适合将 完整的、符合英语语法规则的数字短语 转换为数值。然而，它不适用于解析包含混合文本、部分拼写数字或需要识别重叠模式的任意字符串。例如，对于 eightwothree 或 xtwone3four 这样的输入，word2number 无法直接将其解析为 83 或 24，因为它期望的是一个完整的数字表达，而不是需要从复杂字符串中提取离散数字的场景。

因此，对于本文开头提出的特定问题（即从复杂字符串中提取第一个和最后一个阿拉伯数字或拼写数字），基于正则表达式的方案 (extract_calibration_value) 是更直接和有效的解决方案。word2number 可以作为辅助工具，如果你的任务是先将字符串中的某个子串识别为完整的数字短语，然后再进行转换。

4. 完整解决方案与实践

将上述正则表达式方案整合到一个完整的程序中，使其能够读取文件并处理每一行，计算总和。

import re
import os # 导入os模块用于检查文件是否存在

def extract_calibration_value(line: str) -> int:
    """
    从字符串中提取第一个和最后一个数字（阿拉伯数字或拼写数字），
    并将其组合成一个两位数。
    能够处理重叠的拼写数字。
    """
    word_to_digit = {
        'one': '1', 'two': '2', 'three': '3', 'four': '4',
        'five': '5', 'six': '6', 'seven': '7', 'eight': '8', 'nine': '9'
    }

    # 构建正则表达式模式，使用正向先行断言 (?=...) 处理重叠匹配
    pattern = r'(?=(\d|one|two|three|four|five|six|seven|eight|nine))'

    matches = re.findall(pattern, line.lower())

    if not matches:
        return 0 # 如果没有找到任何数字，返回0

    converted_digits = []
    for match in matches:
        if match.isdigit():
            converted_digits.append(match)
        else:
            converted_digits.append(word_to_digit[match])

    first_digit = int(converted_digits[0])
    last_digit = int(converted_digits[-1])

    return first_digit * 10 + last_digit

def main():
    # 提示用户输入文件名
    nomFichier = input('请输入文件名 (例如: input.txt): ')

    if not nomFichier:
        print("未输入文件名，程序退出。")
        return

    if not os.path.exists(nomFichier):
        print(f"错误: 文件 '{nomFichier}' 不存在。")
        return

    print(f"正在打开文件: {nomFichier}")

    total_sum = 0
    try:
        with open(nomFichier, 'r', encoding='utf-8') as file1: # 使用with语句确保文件正确关闭，并指定编码
            lines = file1.readlines()

            for line_num, line in enumerate(lines):
                clean_line = line.strip() # 移除行首尾的空白字符和换行符
                if not clean_line: # 跳过空行
                    continue

                value = extract_calibration_value(clean_line)
                print(f"  处理行 {line_num + 1}: '{clean_line}' -> 提取值: {value}")
                total_sum += value

        print(f"\n文件 '{nomFichier}' 的总和为: {total_sum}")

    except Exception as e:
        print(f"处理文件时发生错误: {e}")

if __name__ == "__main__":
    main()

使用方法：

1. 将上述代码保存为 .py 文件（例如 calibration_solver.py）。
2. 创建一个文本文件（例如 input.txt），并将示例输入行放入其中：

   two1nine
   eightwothree
   abcone2threexyz
   xtwone3four
   4nineeightseven2
   zoneight234
   7pqrstsixteen

3. 运行Python脚本，当提示时输入 input.txt：

   python calibration_solver.py

   程序将输出每行的处理结果和最终的总和。

5. 注意事项与总结

• 选择合适的工具： 对于从复杂、混合格式字符串中提取特定模式（如本例中的首尾数字），正则表达式通常是更灵活和强大的选择。它能够精确控制匹配逻辑，包括处理重叠模式。而像 word2number 这样的库更适用于将完整、规范的数字短语转换为数值。
• 正则表达式的灵活性与复杂性： 正则表达式功能强大，但也可能变得复杂难懂。在构建复杂模式时，建议逐步测试，并使用在线正则表达式测试工具辅助调试。
• 错误处理： 在文件操作和数值转换中，应加入适当的错误处理机制（如 try-except 块），以提高程序的健壮性。例如，当文件不存在或行中不包含任何可识别的数字时。
• 代码可读性： 即使使用了强大的工具如正则表达式，也要力求代码清晰易懂。为函数和关键逻辑添加注释，有助于他人理解和维护。

总结： 本文详细介绍了如何在Python中从包含阿拉伯数字和英文拼写数字的混合字符串中提取首尾数字。通过深入分析传统字符串替换方法的局限性，我们推荐并演示了基于正则表达式的精确匹配方案，该方案利用零宽先行断言有效解决了重叠匹配的难题。同时，我们也介绍了 word2number 库作为将完整英文数字短语转换为数值的工具，并明确了其在本特定问题中的适用范围。掌握这些技术将有助于您在各种文本处理场景中更高效、更准确地提取数字信息。