如何在首次调用re.sub时实现差异化替换逻辑？

方案1：用闭包封装状态 #

闭包能把状态变量藏在外部函数的作用域里，不会污染全局命名空间，代码更简洁：

import re

def make_repl():
    first_sub = True
    def repl(matchobj):
        nonlocal first_sub
        if first_sub:
            first_sub = False
            print(f"Replacing '{matchobj.group()}' at {matchobj.start()} with ':)'" )
            return ":)"
        else:
            print(f"Deleting '{matchobj.group()}' at {matchobj.start()}")
            return ""
    return repl

text = "hello123 world456"
text = re.sub(r"\d+", make_repl(), text)

# 输出：
#   Replacing '123' at 5 with ':)' 
#   Deleting '456' at 14

这里通过nonlocal让内部函数可以修改外部函数的变量，状态被封闭在make_repl的作用域内，不会影响全局环境。

方案2：手动遍历匹配结果（逻辑更直观） #

如果不想用闭包，也可以直接用re.finditer拿到所有匹配，手动拼接字符串，这种方式逻辑直白，适合需要精细控制的场景：

import re

text = "hello123 world456"
pattern = r"\d+"
matches = list(re.finditer(pattern, text))
result = []
prev_end = 0

for idx, match in enumerate(matches):
    # 添加匹配前的文本片段
    result.append(text[prev_end:match.start()])
    if idx == 0:
        # 首次匹配执行替换
        print(f"Replacing '{match.group()}' at {match.start()} with ':)'" )
        result.append(":)")
    else:
        # 后续匹配直接跳过（即删除）
        print(f"Deleting '{match.group()}' at {match.start()}")
    prev_end = match.end()

# 添加最后一段未匹配的文本
result.append(text[prev_end:])
text = "".join(result)

# 输出：
#   Replacing '123' at 5 with ':)' 
#   Deleting '456' at 14

这种方式不需要依赖替换函数的隐式状态，直接通过索引判断是否为首次匹配，逻辑清晰易懂。

方案3：用类保存状态（适合复杂场景） #

如果后续需要扩展更多状态逻辑，可以用类封装替换行为，把状态存在实例属性里：

import re

class Replacer:
    def __init__(self):
        self.first_sub = True
    
    def __call__(self, matchobj):
        if self.first_sub:
            self.first_sub = False
            print(f"Replacing '{matchobj.group()}' at {matchobj.start()} with ':)'" )
            return ":)"
        else:
            print(f"Deleting '{matchobj.group()}' at {matchobj.start()}")
            return ""

text = "hello123 world456"
replacer = Replacer()
text = re.sub(r"\d+", replacer, text)

# 输出：
#   Replacing '123' at 5 with ':)' 
#   Deleting '456' at 14

类的方式适合需要维护多个状态或有复杂行为的场景，扩展性更强。

内容的提问来源于stack exchange，提问作者Zachary