Python 处理 Excel 身份证号匹配的五种算法方案

五种匹配方案对比

1. 暴力双重循环

这是最直观的方法，但效率极低。

原理：遍历大表每一行，再遍历小表每一行进行比对。

实现：

def algorithm_1_brute_force(small_file, large_file, output_file):
    print("算法 1：暴力双重循环 - 开始执行")
    start_time = time.time()
    
    small_df = pd.read_excel(small_file)
    large_df = pd.read_excel(large_file)
    
    # 确保类型一致
    small_df['id_card'] = small_df['id_card'].astype(str)
    large_df['id_card'] = large_df['id_card'].astype(str)
    
    small_ids = small_df['id_card'].tolist()
    matched_rows = []
    large_ids = large_df['id_card'].tolist()
    
    for i, large_id in enumerate(large_ids):
        for small_id in small_ids:
            if large_id == small_id:
                matched_rows.append(i)
                break
    
    result_df = large_df.iloc[matched_rows]
    result_df.to_excel(output_file, index=False)
    
    end_time = time.time()
    print(f"算法 1 完成。找到 {len(result_df)} 条匹配记录。耗时：{end_time - start_time:.4f} 秒")
    return end_time - start_time

点评：时间复杂度 O(n*m)，对于 14 万 vs 5 千的数据量，预计耗时数十分钟甚至更久，生产环境绝对不可用。

2. Pandas isin() 方法

这是处理此类问题的首选方案之一，利用向量化操作大幅提升速度。

原理：将小表 ID 转为集合（Set），利用哈希查找 O(1) 的特性，配合 isin() 进行布尔索引筛选。

实现：

def algorithm_2_pandas_isin(small_file, large_file, output_file):
    print("算法 2：Pandas isin() - 开始执行")
    start_time = time.time()
    
    small_df = pd.read_excel(small_file)
    large_df = pd.read_excel(large_file)
    
    small_df['id_card'] = small_df['id_card'].astype(str)
    large_df['id_card'] = large_df['id_card'].astype(str)
    
    target_set = set(small_df['id_card'])
    mask = large_df['id_card'].isin(target_set)
    result_df = large_df[mask]
    
    result_df.to_excel(output_file, index=False)
    
    end_time = time.time()
    print(f"算法 2 完成。找到 {len(result_df)} 条匹配记录。耗时：{end_time - start_time:.4f} 秒")
    return end_time - start_time

点评：代码简洁，速度极快（通常 1 秒以内）。内存占用可控，是日常开发中最推荐的方式。

3. Pandas Merge（合并）

利用数据库内连接的思想，语义清晰。

原理：使用 pd.merge() 进行内连接，只保留键值匹配的行。

实现：

def algorithm_3_pandas_merge(small_file, large_file, output_file):
    print("算法 3：Pandas Merge - 开始执行")
    start_time = time.time()
    
    small_df = pd.read_excel(small_file)
    large_df = pd.read_excel(large_file)
    
    small_df['id_card'] = small_df['id_card'].astype(str)
    large_df['id_card'] = large_df['id_card'].astype(str)
    
    # 仅选取 id_card 列作为匹配键，避免产生多余列
    result_df = pd.merge(large_df, small_df[['id_card']], on='id_card', how='inner')
    
    result_df.to_excel(output_file, index=False)
    
    end_time = time.time()
    print(f"算法 3 完成。找到 {len(result_df)} 条匹配记录。耗时：{end_time - start_time:.4f} 秒")
    return end_time - start_time

点评：性能与 isin() 相当，适合需要同时获取关联信息的场景。如果匹配逻辑简单，两者任选其一即可。

4. SQLite 内存数据库

当匹配逻辑复杂或数据量极大时，数据库引擎的优势会显现。

原理：将数据导入内存 SQLite，使用 SQL 语句查询。

实现：

import sqlite3

def algorithm_4_sqlite(small_file, large_file, output_file):
    print("算法 4：SQLite 内存数据库 - 开始执行")
    start_time = time.time()
    
    small_df = pd.read_excel(small_file)
    large_df = pd.read_excel(large_file)
    
    small_df['id_card'] = small_df['id_card'].astype(str)
    large_df['id_card'] = large_df['id_card'].astype(str)
    
    conn = sqlite3.connect(':memory:')
    small_df.to_sql('small_table', conn, index=False)
    large_df.to_sql('large_table', conn, index=False)
    
    query = "SELECT large_table.* FROM large_table WHERE large_table.id_card IN (SELECT id_card FROM small_table)"
    result_df = pd.read_sql_query(query, conn)
    
    conn.close()
    result_df.to_excel(output_file, index=False)
    
    end_time = time.time()
    print(f"算法 4 完成。找到 {len(result_df)} 条匹配记录。耗时：{end_time - start_time:.4f} 秒")
    return end_time - start_time

点评：步骤稍多，有数据迁移开销。但在处理数千万级数据或复杂 SQL 逻辑时，它是强有力的备选方案。

5. 分块处理 (Chunking)

此方案专为解决内存不足问题设计。

原理：分批读取大表，逐块筛选后合并结果。

实现：

def algorithm_5_chunking(small_file, large_file, output_file, chunksize=10000):
    print("算法 5：分块处理 - 开始执行")
    start_time = time.time()
    
    small_df = pd.read_excel(small_file)
    small_df['id_card'] = small_df['id_card'].astype(str)
    target_set = set(small_df['id_card'])
    
    chunks_result_list = []
    chunk_reader = pd.read_excel(large_file, chunksize=chunksize)
    
    for chunk in chunk_reader:
        chunk['id_card'] = chunk['id_card'].astype(str)
        mask = chunk['id_card'].isin(target_set)
        filtered_chunk = chunk[mask]
        chunks_result_list.append(filtered_chunk)
    
    if chunks_result_list:
        final_result_df = pd.concat(chunks_result_list, ignore_index=True)
    else:
        final_result_df = pd.DataFrame()
        
    final_result_df.to_excel(output_file, index=False)
    
    end_time = time.time()
    print(f"算法 5 完成。找到 {len(final_result_df)} 条匹配记录。耗时：{end_time - start_time:.4f} 秒")
    return end_time - start_time

点评：内存友好，但速度略慢于直接加载。仅在文件大到无法一次性读入内存时使用。

总结与建议

最终建议：

1. 常规场景：直接使用 算法二（isin()） 或 算法三（merge()）。它们代码简洁且效率最高，差异可忽略。
2. 海量数据：若小表过大导致内存紧张，考虑 算法四（SQLite） 或 算法五（分块处理）。
3. 复杂逻辑：若匹配条件涉及模糊匹配或复杂规则，建议使用 SQLite 编写 SQL 或使用专用库。
4. 暴力法：仅用于理解时间复杂度概念，切勿在生产环境尝试。

你可以创建一个主函数来运行和比较这些算法（除算法一外）：

if __name__ == '__main__':
    files = ('small.xlsx', 'large.xlsx')
    times = {}
    times['alg_2'] = algorithm_2_pandas_isin(*files, 'result_2.xlsx')
    times['alg_3'] = algorithm_3_pandas_merge(*files, 'result_3.xlsx')
    times['alg_4'] = algorithm_4_sqlite(*files, 'result_4.xlsx')
    times['alg_5'] = algorithm_5_chunking(*files, 'result_5.xlsx', chunksize=50000)
    
    print("\n=== 所有算法耗时对比 ===")
    for alg, t in times.items():
        print(f"{alg}: {t:.4f} 秒")

在实际运行中，你会看到算法二和三以绝对优势胜出。