Python高效对比Excel数据：pandas实战技巧

1. 为什么需要Python处理Excel数据对比

在日常办公和数据分析中，Excel表格的数据对比是个高频需求场景。最常见的情况是：有两列相似但不完全相同的数据，需要快速找出差异项。比如财务对账时核对两期数据、人事管理时对比员工信息变更、供应链管理中匹配订单与库存等。

传统手工对比方法存在三大痛点：

• 人工逐行比对效率低下，200行数据就可能花费半小时
• 容易因视觉疲劳导致遗漏差异项
• 无法保存对比过程和结果留痕

Python的pandas库提供了专业级的数据处理能力，配合openpyxl或xlrd等Excel操作库，可以实现：

1. 毫秒级完成万行数据比对
2. 自动标记所有差异项
3. 生成可视化对比报告
4. 保存对比结果到新Excel文件

提示：虽然Excel自身也有VLOOKUP等函数可以实现简单对比，但当数据量超过5000行时，Excel会明显卡顿，而Python处理10万行数据依然能保持秒级响应。

2. 环境准备与基础配置

2.1 必备库安装

在开始前需要确保已安装以下Python库（通过pip安装）：

bash复制pip install pandas openpyxl xlrd

各库的作用说明：

• pandas：核心数据处理引擎，提供DataFrame数据结构
• openpyxl：读写.xlsx格式的Excel文件
• xlrd：兼容旧版.xls格式文件读取（如需要）

2.2 示例数据准备

创建一个测试用Excel文件（示例命名为comparison_data.xlsx），包含两列待对比数据：

这个示例中故意设置了3处差异（第3、5行及缺失值情况）。

3. 核心对比逻辑实现

3.1 基础比对方案

最基础的比对方法是使用pandas的equals()方法：

python复制import pandas as pd

# 读取Excel文件
df = pd.read_excel('comparison_data.xlsx')

# 提取两列数据
col_new = df['订单编号（新系统）']
col_old = df['订单编号（旧系统）']

# 简单对比
result = col_new.equals(col_old)
print(f"两列数据是否完全一致: {result}")

这种方案只能得到True/False的总体结果，无法定位具体差异项。

3.2 增强型对比方案

更实用的方案是逐行比对并输出差异详情：

python复制# 生成对比结果DataFrame
diff_df = pd.DataFrame({
    '新系统数据': col_new,
    '旧系统数据': col_old,
    '比对结果': ['一致' if new == old else '不一致' 
              for new, old in zip(col_new, col_old)]
})

# 添加行号列便于定位
diff_df.insert(0, '行号', range(1, len(diff_df)+1))

# 筛选出不一致的行
mismatch_rows = diff_df[diff_df['比对结果'] == '不一致']
print("发现差异的行：")
print(mismatch_rows)

这段代码会输出：

code复制发现差异的行：
   行号      新系统数据      旧系统数据 比对结果
2    3  DD20230701-003  DD20230701-005  不一致
4    5  DD20230701-006  DD20230701-007  不一致

3.3 处理空值特殊情况

实际数据中常会遇到空值（NaN），需要特殊处理：

python复制# 改进的对比逻辑，处理NaN情况
def safe_compare(a, b):
    if pd.isna(a) and pd.isna(b):
        return '一致'
    elif pd.isna(a) or pd.isna(b):
        return '不一致（有空值）'
    else:
        return '一致' if a == b else '不一致'

diff_df['比对结果'] = [safe_compare(new, old) 
                     for new, old in zip(col_new, col_old)]

4. 高级对比技巧

4.1 模糊匹配对比

当数据可能存在格式差异时（如空格、大小写），需要预处理：

python复制# 去除空格并统一大写
col_new_clean = col_new.str.strip().str.upper()
col_old_clean = col_old.str.strip().str.upper()

# 使用清洗后的数据对比
diff_df['比对结果'] = ['一致' if new == old else '不一致' 
                     for new, old in zip(col_new_clean, col_old_clean)]

4.2 关键字段部分匹配

有时只需要对比部分字符（如订单号中的日期部分）：

python复制# 提取前10个字符对比（假设前10位是日期）
col_new_date = col_new.str[:10]
col_old_date = col_old.str[:10]

date_diff = col_new_date.compare(col_old_date)
print("日期部分差异：")
print(date_diff)

4.3 使用merge进行表关联对比

对于复杂对比需求，可以使用数据库风格的JOIN操作：

python复制# 将两列视为两个表进行关联
df_new = pd.DataFrame({'data': col_new, 'key': range(len(col_new))})
df_old = pd.DataFrame({'data': col_old, 'key': range(len(col_old))})

# 全外连接找出所有差异
merged = pd.merge(df_new, df_old, on='key', how='outer', 
                 suffixes=('_new', '_old'))
differences = merged[merged['data_new'] != merged['data_old']]

5. 结果输出与可视化

5.1 生成对比报告

将对比结果保存到新Excel文件，并添加样式标记：

python复制from openpyxl import load_workbook
from openpyxl.styles import PatternFill

# 先保存到临时文件
diff_df.to_excel('comparison_result.xlsx', index=False)

# 打开文件添加样式
wb = load_workbook('comparison_result.xlsx')
ws = wb.active

# 设置红色背景填充
red_fill = PatternFill(start_color='FFC7CE', end_color='FFC7CE', fill_type='solid')

# 标记不一致的行
for row in range(2, ws.max_row + 1):
    if ws.cell(row=row, column=4).value != '一致':
        for col in range(1, 5):
            ws.cell(row=row, column=col).fill = red_fill

wb.save('comparison_result_highlighted.xlsx')

5.2 生成差异统计图表

使用matplotlib生成直观的对比图表：

python复制import matplotlib.pyplot as plt

# 统计对比结果
result_counts = diff_df['比对结果'].value_counts()

# 绘制饼图
plt.figure(figsize=(8, 6))
result_counts.plot.pie(autopct='%1.1f%%', startangle=90)
plt.title('数据对比结果分布')
plt.ylabel('')
plt.savefig('comparison_result.png')
plt.show()

6. 性能优化技巧

6.1 大数据量处理

当处理10万行以上数据时，可以采用以下优化措施：

python复制# 使用chunksize分块读取
chunk_size = 10000
results = []

for chunk in pd.read_excel('large_data.xlsx', chunksize=chunk_size):
    # 处理每个数据块
    chunk_diff = chunk[chunk['col1'] != chunk['col2']]
    results.append(chunk_diff)

# 合并所有结果
final_result = pd.concat(results)

6.2 使用dtype参数优化内存

指定列数据类型可以减少内存占用：

python复制dtypes = {'订单编号（新系统）': 'string', 
          '订单编号（旧系统）': 'string'}
df = pd.read_excel('data.xlsx', dtype=dtypes)

6.3 多线程对比

对于CPU密集型的对比操作，可以使用concurrent.futures加速：

python复制from concurrent.futures import ThreadPoolExecutor

def compare_chunk(chunk):
    return chunk[chunk['col1'] != chunk['col2']]

with ThreadPoolExecutor(max_workers=4) as executor:
    futures = []
    for chunk in pd.read_excel('big_file.xlsx', chunksize=5000):
        futures.append(executor.submit(compare_chunk, chunk))
    
    results = [f.result() for f in futures]
final_result = pd.concat(results)

7. 常见问题解决方案

7.1 编码问题处理

当遇到"UnicodeDecodeError"时：

python复制# 尝试指定编码格式
try:
    df = pd.read_excel('data.xlsx')
except UnicodeDecodeError:
    df = pd.read_excel('data.xlsx', encoding='gbk')  # 中文常用编码

7.2 日期格式统一

处理不同日期格式的对比：

python复制# 统一转换为datetime类型
df['日期列1'] = pd.to_datetime(df['日期列1'], errors='coerce')
df['日期列2'] = pd.to_datetime(df['日期列2'], errors='coerce')

# 然后进行对比
date_diff = df[df['日期列1'] != df['日期列2']]

7.3 浮点数精度问题

浮点数对比时需要考虑精度误差：

python复制import numpy as np

# 设置允许的误差范围
tolerance = 1e-6
float_diff = df[np.abs(df['数值列1'] - df['数值列2']) > tolerance]

8. 完整实战案例

下面是一个完整的自动化对比脚本示例：

python复制import pandas as pd
from openpyxl import load_workbook
from openpyxl.styles import PatternFill
import sys

def compare_excel_columns(file_path, sheet_name, col1, col2, output_file):
    try:
        # 读取数据
        df = pd.read_excel(file_path, sheet_name=sheet_name)
        
        # 检查列是否存在
        if col1 not in df.columns or col2 not in df.columns:
            print(f"错误：指定的列名 '{col1}' 或 '{col2}' 不存在")
            print(f"可用列名：{list(df.columns)}")
            return False
            
        # 执行对比
        diff_df = pd.DataFrame({
            '行号': df.index + 2,  # Excel行号从1开始，header占1行
            col1: df[col1],
            col2: df[col2],
            '比对结果': ['一致' if a == b else '不一致' 
                      for a, b in zip(df[col1], df[col2])]
        })
        
        # 保存原始结果
        diff_df.to_excel(output_file, index=False)
        
        # 添加高亮样式
        wb = load_workbook(output_file)
        ws = wb.active
        
        red_fill = PatternFill(start_color='FFC7CE', fill_type='solid')
        yellow_fill = PatternFill(start_color='FFEB9C', fill_type='solid')
        
        for row in range(2, ws.max_row + 1):
            if ws.cell(row=row, column=4).value == '不一致':
                for col in range(1, 5):
                    ws.cell(row=row, column=col).fill = red_fill
            elif pd.isna(ws.cell(row=row, column=2).value) or pd.isna(ws.cell(row=row, column=3).value):
                for col in range(1, 5):
                    ws.cell(row=row, column=col).fill = yellow_fill
        
        # 添加筛选
        ws.auto_filter.ref = ws.dimensions
        
        wb.save(output_file)
        print(f"对比完成，结果已保存到 {output_file}")
        return True
        
    except Exception as e:
        print(f"发生错误：{str(e)}")
        return False

if __name__ == "__main__":
    if len(sys.argv) != 6:
        print("用法: python compare_excel.py 文件路径 工作表名 列1名 列2名 输出文件名")
    else:
        compare_excel_columns(sys.argv[1], sys.argv[2], 
                            sys.argv[3], sys.argv[4], sys.argv[5])

使用方式：

bash复制python compare_excel.py input.xlsx Sheet1 订单编号A 订单编号B result.xlsx

这个脚本实现了：

1. 自动检测输入列是否存在
2. 精确比对两列数据
3. 用不同颜色标记差异项和空值
4. 添加自动筛选功能方便查看
5. 完善的错误处理机制

9. 扩展应用场景

9.1 多列对比

如果需要对比多组列，可以扩展为：

python复制def compare_multiple_columns(file_path, column_pairs):
    df = pd.read_excel(file_path)
    results = []
    
    for col1, col2 in column_pairs:
        temp_df = pd.DataFrame({
            '行号': df.index + 2,
            '列名': f"{col1} vs {col2}",
            col1: df[col1],
            col2: df[col2],
            '比对结果': ['一致' if a == b else '不一致' 
                      for a, b in zip(df[col1], df[col2])]
        })
        results.append(temp_df)
    
    final_result = pd.concat(results)
    return final_result

9.2 跨文件对比

对比两个不同Excel文件的指定列：

python复制def compare_across_files(file1, file2, col1, col2):
    df1 = pd.read_excel(file1)
    df2 = pd.read_excel(file2)
    
    # 确保行数一致
    if len(df1) != len(df2):
        print("警告：两个文件的行数不一致")
    
    # 取最小行数
    n_rows = min(len(df1), len(df2))
    
    result = pd.DataFrame({
        '行号': range(1, n_rows+1),
        '文件1数据': df1[col1][:n_rows],
        '文件2数据': df2[col2][:n_rows],
        '比对结果': ['一致' if a == b else '不一致' 
                  for a, b in zip(df1[col1][:n_rows], df2[col2][:n_rows])]
    })
    
    return result

9.3 数据库与Excel对比

将数据库查询结果与Excel数据对比：

python复制import sqlite3

def compare_with_database(db_path, query, excel_path, excel_col):
    # 从数据库获取数据
    conn = sqlite3.connect(db_path)
    db_data = pd.read_sql(query, conn)
    conn.close()
    
    # 从Excel获取数据
    excel_data = pd.read_excel(excel_path)
    
    # 执行对比
    result = pd.merge(
        db_data, 
        excel_data[[excel_col]], 
        left_on='db_column', 
        right_on=excel_col,
        how='outer',
        indicator=True
    )
    
    # 分类结果
    result['比对结果'] = result['_merge'].map({
        'left_only': '仅在数据库中存在',
        'right_only': '仅在Excel中存在',
        'both': '两者一致'
    })
    
    return result.drop('_merge', axis=1)

10. 最佳实践建议

1. 预处理很重要：对比前先统一格式（去除空格、统一大小写、转换日期格式等）

2. 记录对比日志：建议将每次对比的时间、参数、结果摘要记录到日志文件

3. 异常处理：添加完善的try-catch块处理各种边界情况

4. 性能监控：对于大数据量对比，添加执行时间统计：

   python复制import time
   start = time.time()
   # 对比操作...
   end = time.time()
   print(f"对比完成，耗时 {end - start:.2f} 秒")
   

5. 自动化调度：可以将对比脚本设置为定期任务（如使用Windows任务计划或Linux cron）

6. 结果验证：对于关键业务对比，建议人工抽样验证脚本结果的准确性

7. 版本控制：将对比脚本纳入Git等版本控制系统，记录每次修改

8. 参数化设计：将文件路径、列名等设计为命令行参数，提高脚本复用性

在实际项目中，我通常会建立一个专门的data_validation模块来封装这些对比功能，方便不同项目复用。对于复杂的对比需求，建议先用小样本数据测试脚本的正确性，再应用到全量数据上。