如何高效检测30k个大文件中的跨文件重复行及所属文件？

针对你这种30k个文件、每个100k行的大数量级场景，直接全量合并排序的 naive 方案肯定会遇到内存或性能瓶颈，必须充分利用单文件内已排序且无重复这个关键特性来优化。下面分享几个高效的实现思路：

一、利用Unix工具链（最快最省心） #

Unix/Linux下的sort、awk等工具都是C实现的高性能文本处理工具，尤其适合这种超大文本场景。核心思路是用sort -m（merge排序，专门针对已排序的输入文件）来高效合并，再用awk跟踪统计跨文件的重复行。

命令示例： #

# 给每行加上文件名前缀，用制表符分隔便于后续处理
awk '{print FILENAME "\t" $0}' *.txt | 
# 按行内容（第二列）进行merge排序，因为每个输入文件已排序，merge排序效率远高于全排序
sort -m -k2,2 | 
# 统计每个行内容对应的文件列表，筛选出出现≥2次的行
awk '
    prev_line != $2 {
        if (count >= 2) {
            print "重复行: " prev_line
            print "涉及文件: " files
            print "---"
        }
        prev_line = $2
        count = 1
        files = $1
        next
    }
    {
        # 因为单文件内无重复，只要文件名不同就计数+1
        if ($1 != files && index(files, $1) == 0) {
            count++
            files = files ", " $1
        }
    }
    END {
        # 处理最后一组行
        if (count >= 2) {
            print "重复行: " prev_line
            print "涉及文件: " files
        }
    }'

优势： #

• 完全流式处理，内存占用极低，不会因为数据量大而崩溃
• sort -m的时间复杂度是O(n)（n为总行数），比全排序的O(n log n)快一个数量级
• 工具链成熟，无需额外编写复杂代码

二、Python流式实现（跨平台灵活定制） #

如果需要跨平台运行，或者要添加更复杂的业务逻辑，用Python结合heapq.merge来实现merge排序是个不错的选择，同样基于流式处理，内存友好。

代码示例： #

import heapq
import os
from typing import Generator, Tuple

def file_line_generator(file_path: str) -> Generator[Tuple[str, str], None, None]:
    """生成器：读取文件，返回(行内容, 文件名)的元组"""
    with open(file_path, 'r', encoding='utf-8') as f:
        for line in f:
            stripped_line = line.strip()
            if stripped_line:  # 跳过空行（如果有的话）
                yield (stripped_line, file_path)

if __name__ == "__main__":
    # 替换成你的目标文件路径匹配规则
    target_files = [
        f for f in os.listdir('.') 
        if os.path.isfile(f) and f.endswith('.txt')  # 假设处理txt文件
    ]

    # 创建所有文件的生成器列表
    generators = [file_line_generator(fp) for fp in target_files]

    prev_line = None
    related_files = set()

    # 用heapq.merge合并多个已排序的生成器，按行内容排序
    for current_line, current_file in heapq.merge(*generators, key=lambda x: x[0]):
        if current_line != prev_line:
            # 上一组行满足重复条件，输出结果
            if len(related_files) >= 2:
                print(f"重复行: {prev_line}")
                print(f"涉及文件: {', '.join(related_files)}")
                print("---")
            # 重置跟踪状态
            prev_line = current_line
            related_files = {current_file}
        else:
            # 同一个行出现新文件，加入集合
            related_files.add(current_file)

    # 处理最后一组行
    if len(related_files) >= 2:
        print(f"重复行: {prev_line}")
        print(f"涉及文件: {', '.join(related_files)}")

优势： #

• 跨平台支持Windows/macOS/Linux
• 可以灵活扩展逻辑（比如过滤特定行、输出格式定制等）
• heapq.merge基于堆实现，时间复杂度O(n log k)（k为文件数），比全排序高效很多

三、不推荐的方案：内存哈希表 #

如果尝试用字典（哈希表）直接存储所有行和对应的文件名集合，对于300亿行的数据量来说，内存完全无法承受（即使每行100字节，也需要300GB以上内存），除非你的数据重复率极高，但这种情况非常罕见，所以不推荐。

总结 #

优先推荐Unix工具链方案，性能最优；如果需要跨平台或定制化需求，选择Python流式实现。核心原则都是避免全量加载数据到内存，利用已排序特性做merge排序，流式跟踪统计。

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