Python 代码中基于正则的清洗策略详解

我来逐行、逐段、零基础讲解这段 Python 代码，你不需要任何高级知识也能完全看懂。

逐行完整讲解

import re

• 导入 Python 自带的正则表达式库，用来做文本查找、替换、匹配。

import logging

• 导入日志库，用来打印提示、警告、错误信息，方便调试。

from typing import Any, Dict, List, Tuple

• 导入类型注解工具，用来标注变量是什么类型（比如列表、字典、字符串）。
• 让代码更易读、编辑器能自动提示错误。

from .base import CleaningStrategy

• 从当前文件夹的 base.py 导入一个基类 CleaningStrategy（清洗策略父类）。
• 这个类是所有清洗策略的“模板”。

from ..core.enums import ContentType

• 从上一级文件夹的 core/enums.py 导入内容类型枚举。
• 比如：纯文本、Markdown、PDF 提取文本等。

from ..core.models import CleanRule

• 从上一级文件夹的 core/models.py 导入清洗规则模型。
• 每个规则包含：正则表达式、替换内容、优先级、是否启用等。

class RegexCleaningStrategy(CleaningStrategy):

• 定义一个类，名字叫 RegexCleaningStrategy。
• 它继承自 CleaningStrategy，必须实现父类规定的方法。
• 作用：用正则表达式批量清洗文本。

    """基于正则的通用清洗策略"""

• 类的说明文档，解释这个类是干嘛的。

    def __init__(self, rules: List[CleanRule]):

• 构造方法：创建这个类的时候必须传入一组清洗规则。

        self.rules = sorted([r for r in rules if r.enabled], key=lambda x: x.priority)

• 只保留启用的规则（enabled=True）
• 按照优先级（priority）从小到大排序

        self._compiled_rules: List[Tuple[CleanRule, re.Pattern]] = []

• 存放预编译好的正则规则（编译后运行更快）
• 格式：(规则对象, 编译后的正则模式)

        self._compile_rules()

• 调用方法，把所有正则提前编译

        self.logger = logging.getLogger(self.__class__.__name__)

• 创建日志打印器，名字就是类名：RegexCleaningStrategy

    def _compile_rules(self):
        """预编译所有规则"""

• 私有方法：只在类内部使用，编译正则提升速度。

        self._compiled_rules = []

• 清空已编译规则

        for rule in self.rules:
            compiled = rule.compile()
            if compiled:
                self._compiled_rules.append((rule, compiled))

• 遍历所有规则
• 调用规则自己的 compile() 编译正则
• 如果编译成功，保存到列表

    @property
    def name(self) -> str:
        return "regex_strategy"

• 属性方法：返回策略名字，方便系统识别这是正则清洗策略。

    @property
    def supported_types(self) -> List[ContentType]:
        return [
            ContentType.PLAIN_TEXT,
            ContentType.MARKDOWN,
            ContentType.PDF_EXTRACT
        ]

• 这个策略支持清洗哪些类型的内容：
  • 纯文本
  • Markdown
  • PDF 提取文本

    def clean(self, content: str, context: Dict[str, Any]) -> Tuple[str, List[str]]:

• 核心方法：清洗文本
• 输入：原始文本 + 上下文（比如内容类型）
• 输出：(清洗后文本, 应用过的规则名字列表)

        applied_rules = []

• 记录哪些规则真正生效了

        cleaned = content

• 把原始内容复制一份，避免修改原数据

        content_type = context.get("content_type", ContentType.PLAIN_TEXT)

• 获取当前要清洗的内容类型，默认是纯文本

        for rule, pattern in self._compiled_rules:

• 遍历所有预编译好的正则规则

            # 检查内容类型匹配
            if rule.content_types and content_type not in rule.content_types:
                continue

• 如果这条规则不支持当前内容类型，直接跳过

            try:

• 异常捕获：防止某条规则出错导致整个程序崩溃

                new_cleaned = pattern.sub(rule.replacement, cleaned)

• 正则替换核心代码
• 把文本中匹配到的内容 → 替换成规则指定的内容

                if new_cleaned != cleaned:
                    applied_rules.append(rule.name)
                    cleaned = new_cleaned
                    self.logger.debug(f"Rule '{rule.name}' applied")

• 如果文本发生变化 → 记录这条规则生效
• 更新清洗后的文本
• 打印日志

            except Exception as e:
                self.logger.warning(f"Rule '{rule.name}' failed: {e}")

• 某条规则报错 → 只打警告，不崩溃

        return cleaned, applied_rules

• 返回：清洗完的文本 + 用了哪些规则

整体功能一句话总结

这个类是一个基于正则表达式的文本清洗工具：

1. 接收一组正则清洗规则
2. 自动按优先级排序、预编译正则
3. 遍历规则批量替换文本
4. 跳过不支持的内容类型
5. 记录哪些规则生效、防止崩溃
6. 返回清洗后的内容

最简单的使用示例（帮助理解）

# 假设有两条规则
rule1 = CleanRule(
    name="去掉空格",
    regex=r"\s+",
    replacement="",
    enabled=True,
    priority=1
)
rule2 = CleanRule(
    name="去掉数字",
    regex=r"\d+",
    replacement="",
    enabled=True,
    priority=2
)
# 创建策略
cleaner = RegexCleaningStrategy(rules=[rule1, rule2])
# 清洗文本
result, used_rules = cleaner.clean(
    content="我 是 123 测 试 文 本",
    context={"content_type": ContentType.PLAIN_TEXT}
)
print(result)      # 输出：我是测试文本
print(used_rules)  # 输出：['去掉空格', '去掉数字']

总结

1. 这是一个可复用、可扩展、健壮的正则文本清洗工具
2. 支持优先级、启用开关、内容类型过滤、异常安全
3. 核心就是：编译正则 → 遍历替换 → 返回结果
4. 非常适合用于：敏感词过滤、格式清理、垃圾文本删除、标准化文本