使用joblib并行处理嵌套循环找文本重复时如何追踪输入原始索引

你现在拿到的结果全是小范围的局部索引，是两个问题叠加导致的：

• 并行调用的参数传递完全错位：你写的map(delayed(match_name), texts)会把texts里的每一个单独字符串传给match_name当实参，而match_name内部是把传入的texts形参当成完整文本列表在跑双重循环，实际运行时enumerate遍历的是单个字符串的每个字符，自然只会生成字符长度范围内的极小索引，根本碰不到50万级别的全局索引范围。
• 任务没有携带全局位置上下文：拆分给各并行进程的任务，本身没有绑定它在原始大列表里的位置偏移，函数内部根本不知道当前处理的内容在原列表的位置，只能生成进程内的局部计数。

只要做到一点就能解决：拆分并行任务时，主动把每个任务对应的全局索引信息传入函数，函数内部计算索引时叠加全局偏移，替换掉原来的纯局部enumerate值。

修正后的可运行代码 #

import time
from fuzzywuzzy import fuzz
from joblib import Parallel, delayed

start_time = time.time()
texts = a_list  # 50万+长度的原始文本列表
total_len = len(texts)

def check_duplicate_pair(base_global_idx, base_text, all_texts):
    """
    函数完全不依赖隐式的索引计数，所有索引都是显式传入/计算的全局值
    """
    result = []
    # 和原逻辑保持一致，只和基准索引之后的文本比对，避免重复计算
    for compare_global_idx in range(base_global_idx + 1, total_len):
        compare_text = all_texts[compare_global_idx]
        ratio = fuzz.token_set_ratio(base_text, compare_text)
        if ratio >= 75:
            # 记录的全是原始全局索引，不存在局部值
            result.append([base_global_idx, compare_global_idx, ratio])
    return result

# 生成任务时，给每个任务绑定对应的全局基准索引
task_list = [(i, texts[i], texts) for i in range(total_len)]

results2 = Parallel(
    n_jobs=200, 
    verbose=5, 
    backend="loky"
)(
    delayed(check_duplicate_pair)(base_idx, base_txt, full_texts)
    for base_idx, base_txt, full_texts in task_list
)

print(f"运行耗时：{time.time() - start_time}")

内存优化版（适合50万+大列表，避免重复序列化大列表） #

如果觉得每个任务都传完整50万条列表太占内存，可以把原始列表拆成连续的块，每个块只传入对应范围的文本，同时记录块的全局起始索引：

CHUNK_SIZE = 1000  # 可根据内存大小调整块大小
chunk_tasks = []
total_len = len(texts)

for start_global_idx in range(0, total_len, CHUNK_SIZE):
    # 切出当前块的文本片段
    chunk_text = texts[start_global_idx : start_global_idx + CHUNK_SIZE]
    # 块内文本需要比对的后续范围文本
    compare_pool = texts[start_global_idx:]
    chunk_tasks.append((start_global_idx, chunk_text, compare_pool))

def match_in_chunk(chunk_start_idx, chunk_text, compare_pool):
    result = []
    for local_i, text in enumerate(chunk_text):
        # 局部索引 + 块的全局起始位置 = 原始列表的全局索引i
        global_i = chunk_start_idx + local_i
        for local_j_offset, name in enumerate(compare_pool[local_i + 1:]):
            # 偏移量 + 全局i = 原始列表的全局索引j
            global_j = global_i + 1 + local_j_offset
            fratio = fuzz.token_set_ratio(text, name)
            if fratio >=75:
                result.append([global_i, global_j, fratio])
    return result

results2 = Parallel(n_jobs=200, verbose=5, backend="loky")(
    delayed(match_in_chunk)(start_idx, c_text, pool)
    for start_idx, c_text, pool in chunk_tasks
)

• 所有需要追踪的原始索引，不要依赖函数内部自动生成，必须在生成并行任务时，就把对应的全局值当参数显式传入。并行进程拿到的所有上下文都是任务启动时序列化传入的，不会自动帮你定位处理内容在原列表的位置。
• n_jobs=200的配置在50万条文本的场景下要警惕内存溢出：loky后端会给每个worker分配独立内存，如果每个worker都存一份全列表的话很容易把内存占满，优先用块拆分的方式切分任务，减少重复的列表序列化开销。
• 原代码把整个texts列表当参数传给每个单条任务的写法，会导致joblib重复序列化大列表几百次，大幅拖慢运行速度，改成块传递的模式能明显提升效率。

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