如何从Python difflib.ndiff获取结构化差异数据而非纯字符串？

刚好之前处理过类似的字符级文件对比需求，来给你梳理几个实用的方案，完全能满足你自定义行号标注、精细处理差异的需求！

difflib.SequenceMatcher 是 ndiff 和 Differ 的底层核心，它能直接返回结构化的差异操作码，不用你去解析 ndiff 返回的字符串。你可以通过它的 get_opcodes() 方法拿到每个差异段的类型（相等、替换、删除、插入）以及对应在两个文件中的位置索引，完全可控地生成带行号的日志。

举个具体的实现例子：

from difflib import SequenceMatcher

def generate_detailed_diff(old_file_path, new_file_path):
    # 读取两个文件的内容（按行保留换行符，方便后续计算位置）
    with open(old_file_path, "r", encoding="utf-8") as f:
        old_lines = f.readlines()
    with open(new_file_path, "r", encoding="utf-8") as f:
        new_lines = f.readlines()

    # 初始化SequenceMatcher，对比行序列
    line_matcher = SequenceMatcher(None, old_lines, new_lines)

    # 遍历每一段差异操作
    for tag, i1, i2, j1, j2 in line_matcher.get_opcodes():
        old_segment = old_lines[i1:i2]
        new_segment = new_lines[j1:j2]

        if tag == "equal":
            # 行完全匹配，输出行号和内容
            for line_idx, line in enumerate(old_segment, start=i1+1):
                print(f"  Line {line_idx}: {line.strip()}")
        elif tag == "replace":
            # 行被替换，进一步做字符级对比
            print(f"* Lines {i1+1}-{i2} → Lines {j1+1}-{j2} (字符差异标记：[]表示替换，()表示新增/删除)")
            for old_line, new_line in zip(old_segment, new_segment):
                char_matcher = SequenceMatcher(None, old_line, new_line)
                old_display, new_display = [], []
                # 处理每行内的字符差异
                for char_tag, c_i1, c_i2, c_j1, c_j2 in char_matcher.get_opcodes():
                    if char_tag == "equal":
                        old_display.append(old_line[c_i1:c_i2])
                        new_display.append(new_line[c_j1:c_j2])
                    elif char_tag == "replace":
                        old_display.append(f"[{old_line[c_i1:c_i2]}]")
                        new_display.append(f"[{new_line[c_j1:c_j2]}]")
                    elif char_tag == "delete":
                        old_display.append(f"({old_line[c_i1:c_i2]})")
                    elif char_tag == "insert":
                        new_display.append(f"({new_line[c_j1:c_j2]})")
                print(f"  Old: {''.join(old_display).strip()}")
                print(f"  New: {''.join(new_display).strip()}")
        elif tag == "delete":
            # 行被删除
            print(f"- Lines {i1+1}-{i2} 已移除：")
            for line_idx, line in enumerate(old_segment, start=i1+1):
                print(f"  Line {line_idx}: {line.strip()}")
        elif tag == "insert":
            # 新增行
            print(f"+ Lines {j1+1}-{j2} 已新增：")
            for line_idx, line in enumerate(new_segment, start=j1+1):
                print(f"  Line {line_idx}: {line.strip()}")

# 调用示例
generate_detailed_diff("old_version.txt", "new_version.txt")

这个代码会输出带行号、字符级标记的清晰日志，完全符合你的需求。

Differ 其实是对 SequenceMatcher 的封装，它的 compare() 方法返回的是行级差异字符串，但如果要做字符级处理，还是得像上面一样，对标记为差异的行单独用 SequenceMatcher 做字符对比。所以直接用 SequenceMatcher 反而更灵活，没必要绕一圈用 Differ。

如果不想自己写太多逻辑，可以试试 diff-match-patch——这是Google开源的专门处理文本差异的库，对字符级差异的支持非常成熟，还自带语义化清理差异的功能。

安装后用起来很简单：

from diff_match_patch import diff_match_patch

def dmp_detailed_diff(old_file_path, new_file_path):
    dmp = diff_match_patch()
    with open(old_file_path, "r", encoding="utf-8") as f:
        old_text = f.read()
    with open(new_file_path, "r", encoding="utf-8") as f:
        new_text = f.read()

    # 获取字符级差异，并做语义化清理
    diffs = dmp.diff_main(old_text, new_text)
    dmp.diff_cleanupSemantic(diffs)

    # 生成带行号的日志（这里简化了行号计算逻辑，你可以根据需求优化）
    old_lines = old_text.splitlines(keepends=True)
    new_lines = new_text.splitlines(keepends=True)
    old_pos, new_pos = 0, 0

    for tag, text in diffs:
        if tag == -1:
            # 计算删除文本对应的旧行号
            line_num = next(i+1 for i, line in enumerate(old_lines) if old_pos < old_pos + len(line))
            print(f"- Line {line_num}: ({text.strip()})")
            old_pos += len(text)
        elif tag == 1:
            # 计算新增文本对应的新行号
            line_num = next(i+1 for i, line in enumerate(new_lines) if new_pos < new_pos + len(line))
            print(f"+ Line {line_num}: ({text.strip()})")
            new_pos += len(text)
        else:
            # 相同文本，行号一致
            line_num = next(i+1 for i, line in enumerate(old_lines) if old_pos < old_pos + len(line))
            print(f"  Line {line_num}: {text.strip()}")
            old_pos += len(text)
            new_pos += len(text)

这个库的优势是不需要自己处理字符级差异的细节，适合快速实现需求。

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