Python办公自动化完全指南：Word与Excel文档处理库深度对比与实战

原创于 2025-10-04 11:28:55 发布 · 1k 阅读

21 ·

CC 4.0 BY-SA版权

文章标签：

#python #word #excel #pandas #pip

Python 专栏收录该内容

101 篇文章

订阅专栏

文章目录

Python办公自动化完全指南：Word与Excel文档处理库深度对比与实战

Python办公自动化完全指南：Word与Excel文档处理库深度对比与实战

概述：Python文档处理生态全景

Python提供了丰富的库来处理Microsoft Office文档，每个库都有其特定的优势和使用场景。本文将深度解析主流Word和Excel处理库，帮助您选择最适合的工具。

一、Word文档处理库

1.1 python-docx - 官方风格Word处理

功能特点：

创建、修改Word文档（.docx格式）
支持段落、表格、图片、样式等
读取现有文档内容

代码示例：

from docx import Document
from docx.shared import Inches, Pt
from docx.enum.text import WD_ALIGN_PARAGRAPH
from docx.oxml.ns import qn

def create_word_document():
    # 创建文档
    doc = Document()
    
    # 设置中文字体
    doc.styles['Normal'].font.name = '微软雅黑'
    doc.styles['Normal']._element.rPr.rFonts.set(qn('w:eastAsia'), '微软雅黑')
    
    # 添加标题
    title = doc.add_heading('企业项目报告', 0)
    title.alignment = WD_ALIGN_PARAGRAPH.CENTER
    
    # 添加段落
    p1 = doc.add_paragraph('这是一个示例文档，展示了')
    p1.add_run('python-docx').bold = True
    p1.add_run('库的强大功能。')
    
    # 添加表格
    table = doc.add_table(rows=3, cols=3)
    table.style = 'Light Grid Accent 1'
    
    # 填充表头
    headers = table.rows[0].cells
    headers[0].text = '项目'
    headers[1].text = '负责人'
    headers[2].text = '进度'
    
    # 填充数据
    data = [
        ['项目A', '张三', '80%'],
        ['项目B', '李四', '60%'],
        ['项目C', '王五', '90%']
    ]
    
    for i, row_data in enumerate(data, 1):
        row = table.rows[i].cells
        for j, cell_data in enumerate(row_data):
            row[j].text = cell_data
    
    # 保存文档
    doc.save('项目报告.docx')
    print("Word文档创建成功")

def read_word_document(file_path):
    """读取Word文档内容"""
    doc = Document(file_path)
    content = {
        'paragraphs': [],
        'tables': []
    }
    
    # 读取段落
    for paragraph in doc.paragraphs:
        if paragraph.text.strip():
            content['paragraphs'].append({
                'text': paragraph.text,
                'style': paragraph.style.name
            })
    
    # 读取表格
    for i, table in enumerate(doc.tables):
        table_data = []
        for row in table.rows:
            row_data = [cell.text for cell in row.cells]
            table_data.append(row_data)
        content['tables'].append(table_data)
    
    return content

# 使用示例
if __name__ == "__main__":
    create_word_document()
    content = read_word_document('项目报告.docx')
    print("文档内容:", content)

1.2 docxtpl - 模板化Word生成

功能特点：

基于Jinja2模板引擎
支持动态内容插入
条件判断和循环

代码示例：

from docxtpl import DocxTemplate
import json
from datetime import datetime

def generate_contract_from_template():
    # 加载模板
    doc = DocxTemplate("contract_template.docx")
    
    # 准备数据
    context = {
        'contract_number': 'HT2024001',
        'date': datetime.now().strftime('%Y年%m月%d日'),
        'party_a': {
            'name': '某某科技有限公司',
            'address': '北京市海淀区xx路xx号',
            'contact': '张经理',
            'phone': '13800138000'
        },
        'party_b': {
            'name': '李四',
            'id_card': '110101199001011234',
            'address': '上海市浦东新区xx街道',
            'phone': '13900139000'
        },
        'project': {
            'name': '企业官网开发项目',
            'amount': 50000,
            'duration': '30天',
            'start_date': '2024-01-15',
            'end_date': '2024-02-14'
        },
        'payment_terms': [
            {'stage': '第一期', 'condition': '合同签订后', 'percentage': 30, 'amount': 15000},
            {'stage': '第二期', 'condition': '设计稿确认后', 'percentage': 40, 'amount': 20000},
            {'stage': '第三期', 'condition': '项目验收后', 'percentage': 30, 'amount': 15000}
        ],
        'terms_and_conditions': [
            '甲方应按约定时间支付款项',
            '乙方应保证项目质量符合要求',
            '双方应友好协商解决争议'
        ]
    }
    
    # 渲染并保存
    doc.render(context)
    doc.save(f"合同_{context['contract_number']}.docx")
    print("合同生成成功")

# 模板内容示例（contract_template.docx中应包含类似内容）：
"""
合同编号：{{ contract_number }}
签订日期：{{ date }}

甲方（委托方）：
单位名称：{{ party_a.name }}
地址：{{ party_a.address }}
联系人：{{ party_a.contact }}
电话：{{ party_a.phone }}

乙方（受托方）：
姓名：{{ party_b.name }}
身份证号：{{ party_b.id_card }}
地址：{{ party_b.address }}
电话：{{ party_b.phone }}

项目名称：{{ project.name }}
项目金额：人民币{{ project.amount }}元
项目周期：{{ project.duration }}

付款方式：
{% for payment in payment_terms %}
{{ payment.stage }}：{{ payment.condition }}支付{{ payment.percentage }}%，即人民币{{ payment.amount }}元
{% endfor %}

条款与条件：
{% for term in terms_and_conditions %}
{{ loop.index }}. {{ term }}
{% endfor %}
"""

二、Excel文档处理库

2.1 openpyxl - 现代Excel文件处理

功能特点：

读写.xlsx格式
支持公式、图表、样式
内存效率高

代码示例：

from openpyxl import Workbook, load_workbook
from openpyxl.styles import Font, PatternFill, Alignment, Border, Side
from openpyxl.chart import BarChart, Reference
from openpyxl.utils import get_column_letter
import datetime

def create_advanced_excel_report():
    # 创建工作簿
    wb = Workbook()
    ws = wb.active
    ws.title = "销售报表"
    
    # 定义样式
    header_font = Font(name='微软雅黑', bold=True, size=12, color='FFFFFF')
    header_fill = PatternFill(start_color='366092', end_color='366092', fill_type='solid')
    border = Border(left=Side(style='thin'), right=Side(style='thin'),
                   top=Side(style='thin'), bottom=Side(style='thin'))
    center_align = Alignment(horizontal='center', vertical='center')
    
    # 设置表头
    headers = ['日期', '产品名称', '销售数量', '单价', '销售额', '销售人员', '地区']
    for col, header in enumerate(headers, 1):
        cell = ws.cell(row=1, column=col, value=header)
        cell.font = header_font
        cell.fill = header_fill
        cell.border = border
        cell.alignment = center_align
    
    # 示例数据
    sales_data = [
        ['2024-01-01', '产品A', 150, 299, '=C2*D2', '张三', '华北'],
        ['2024-01-01', '产品B', 200, 199, '=C3*D3', '李四', '华东'],
        ['2024-01-02', '产品A', 180, 299, '=C4*D4', '王五', '华南'],
        ['2024-01-02', '产品C', 120, 399, '=C5*D5', '赵六', '西南'],
        ['2024-01-03', '产品B', 220, 199, '=C6*D6', '张三', '华北'],
    ]
    
    # 填充数据
    for row, data in enumerate(sales_data, 2):
        for col, value in enumerate(data, 1):
            cell = ws.cell(row=row, column=col, value=value)
            cell.border = border
            if col not in [5]:  # 非公式列居中对齐
                cell.alignment = center_align
    
    # 自动调整列宽
    for column in ws.columns:
        max_length = 0
        column_letter = get_column_letter(column[0].column)
        for cell in column:
            try:
                if len(str(cell.value)) > max_length:
                    max_length = len(str(cell.value))
            except:
                pass
        adjusted_width = (max_length + 2) * 1.2
        ws.column_dimensions[column_letter].width = adjusted_width
    
    # 创建图表
    chart = BarChart()
    chart.type = "col"
    chart.style = 10
    chart.title = "产品销售对比"
    chart.y_axis.title = '销售数量'
    chart.x_axis.title = '产品名称'
    
    data = Reference(ws, min_col=3, min_row=1, max_row=6, max_col=3)
    categories = Reference(ws, min_col=2, min_row=2, max_row=6)
    chart.add_data(data, titles_from_data=True)
    chart.set_categories(categories)
    
    ws.add_chart(chart, "H2")
    
    # 创建汇总表
    ws_summary = wb.create_sheet("汇总")
    summary_headers = ['产品名称', '总销售数量', '总销售额']
    for col, header in enumerate(summary_headers, 1):
        ws_summary.cell(row=1, column=col, value=header).font = header_font
    
    # 使用公式汇总
    products = ['产品A', '产品B', '产品C']
    for i, product in enumerate(products, 2):
        ws_summary.cell(row=i, column=1, value=product)
        ws_summary.cell(row=i, column=2, 
                       value=f'=SUMIF(销售报表!B:B,A{i},销售报表!C:C)')
        ws_summary.cell(row=i, column=3,
                       value=f'=SUMIF(销售报表!B:B,A{i},销售报表!E:E)')
    
    # 保存文件
    filename = f"销售报表_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
    wb.save(filename)
    print(f"Excel报表已生成: {filename}")

def read_excel_analysis(file_path):
    """读取并分析Excel文件"""
    wb = load_workbook(file_path, data_only=True)  # data_only=True 获取公式计算结果
    analysis = {}
    
    for sheet_name in wb.sheetnames:
        ws = wb[sheet_name]
        analysis[sheet_name] = {
            'dimensions': f"{ws.max_row}行 {ws.max_column}列",
            'data': []
        }
        
        # 读取前5行数据作为示例
        for row in ws.iter_rows(min_row=1, max_row=min(5, ws.max_row), values_only=True):
            analysis[sheet_name]['data'].append(row)
    
    return analysis

# 使用示例
if __name__ == "__main__":
    create_advanced_excel_report()
    # analysis = read_excel_analysis("销售报表_20240101_120000.xlsx")
    # print("Excel分析结果:", analysis)

2.2 pandas - 数据分析首选

功能特点：

强大的数据处理能力
简洁的API
与其他数据科学库完美集成

代码示例：

import pandas as pd
import numpy as np
from datetime import datetime, timedelta

def pandas_excel_operations():
    """使用pandas进行高级Excel操作"""
    
    # 创建示例数据
    np.random.seed(42)
    dates = pd.date_range('2024-01-01', periods=100, freq='D')
    
    df_sales = pd.DataFrame({
        'date': dates,
        'product': np.random.choice(['产品A', '产品B', '产品C'], 100),
        'quantity': np.random.randint(10, 100, 100),
        'price': np.random.choice([199, 299, 399], 100),
        'region': np.random.choice(['华北', '华东', '华南', '西南'], 100),
        'salesperson': np.random.choice(['张三', '李四', '王五', '赵六'], 100)
    })
    
    # 计算销售额
    df_sales['revenue'] = df_sales['quantity'] * df_sales['price']
    
    # 数据透视表
    pivot_table = pd.pivot_table(df_sales, 
                                values='revenue', 
                                index='product', 
                                columns='region', 
                                aggfunc='sum',
                                fill_value=0,
                                margins=True,
                                margins_name='总计')
    
    # 分组统计
    summary = df_sales.groupby(['product', 'salesperson']).agg({
        'quantity': 'sum',
        'revenue': 'sum'
    }).round(2)
    
    # 时间序列分析
    df_sales['month'] = df_sales['date'].dt.to_period('M')
    monthly_sales = df_sales.groupby('month')['revenue'].sum()
    
    # 使用ExcelWriter创建多sheet的Excel文件
    with pd.ExcelWriter('高级销售分析.xlsx', engine='openpyxl') as writer:
        # 原始数据
        df_sales.to_excel(writer, sheet_name='原始数据', index=False)
        
        # 数据透视表
        pivot_table.to_excel(writer, sheet_name='区域销售透视')
        
        # 汇总统计
        summary.to_excel(writer, sheet_name='销售员业绩')
        
        # 月度趋势
        monthly_sales.to_excel(writer, sheet_name='月度趋势')
        
        # 获取workbook对象进行格式设置
        workbook = writer.book
        worksheet = writer.sheets['原始数据']
        
        # 设置列宽
        for column in worksheet.columns:
            max_length = 0
            column_letter = column[0].column_letter
            for cell in column:
                try:
                    if len(str(cell.value)) > max_length:
                        max_length = len(str(cell.value))
                except:
                    pass
            adjusted_width = (max_length + 2)
            worksheet.column_dimensions[column_letter].width = adjusted_width
    
    print("高级Excel分析报告已生成")
    
    # 读取Excel进行进一步分析
    df_read = pd.read_excel('高级销售分析.xlsx', sheet_name='原始数据')
    
    # 数据分析示例
    analysis_results = {
        'total_revenue': df_read['revenue'].sum(),
        'avg_quantity': df_read['quantity'].mean(),
        'top_product': df_read.groupby('product')['revenue'].sum().idxmax(),
        'revenue_by_region': df_read.groupby('region')['revenue'].sum().to_dict()
    }
    
    print("数据分析结果:")
    for key, value in analysis_results.items():
        print(f"{key}: {value}")
    
    return df_read, analysis_results

# 使用示例
if __name__ == "__main__":
    df, results = pandas_excel_operations()

2.3 xlwings - Excel自动化神器

功能特点：

与Excel应用程序交互
支持VBA调用
实时操作Excel

代码示例：

import xlwings as xw
import pandas as pd
import time

def excel_automation_with_xlwings():
    """使用xlwings进行Excel自动化"""
    
    # 启动Excel应用程序
    app = xw.App(visible=True)  # visible=True 显示Excel界面
    
    try:
        # 创建新工作簿
        wb = app.books.add()
        ws = wb.sheets['Sheet1']
        
        # 写入数据
        data = [
            ['月份', '产品A', '产品B', '产品C', '总计'],
            ['1月', 1000, 1500, 800, '=SUM(B2:D2)'],
            ['2月', 1200, 1600, 900, '=SUM(B3:D3)'],
            ['3月', 1100, 1700, 850, '=SUM(B4:D4)'],
            ['4月', 1300, 1800, 950, '=SUM(B5:D5)'],
            ['5月', 1400, 1900, 1000, '=SUM(B6:D6)'],
            ['6月', 1500, 2000, 1100, '=SUM(B7:D7)']
        ]
        
        # 批量写入数据
        ws.range('A1').value = data
        
        # 设置格式
        ws.range('A1:E1').color = (91, 155, 213)  # 蓝色背景
        ws.range('A1:E1').api.Font.Color = 0xFFFFFF  # 白色文字
        ws.range('A1:E1').api.Font.Bold = True
        
        # 自动调整列宽
        ws.autofit()
        
        # 创建图表
        chart = ws.charts.add()
        chart.set_source_data(ws.range('A1:D7'))
        chart.chart_type = 'column_clustered'
        chart.top = ws.range('A9').top
        chart.left = ws.range('A9').left
        chart.width = 500
        chart.height = 300
        
        # 添加数据透视表
        pivot_data = [
            ['区域', '季度', '产品', '销售额'],
            ['华北', 'Q1', '产品A', 50000],
            ['华北', 'Q1', '产品B', 60000],
            ['华东', 'Q1', '产品A', 55000],
            ['华东', 'Q1', '产品B', 65000],
            ['华北', 'Q2', '产品A', 52000],
            ['华北', 'Q2', '产品B', 62000],
            ['华东', 'Q2', '产品A', 58000],
            ['华东', 'Q2', '产品B', 68000],
        ]
        
        # 创建第二个工作表用于数据透视表
        ws_data = wb.sheets.add('原始数据')
        ws_data.range('A1').value = pivot_data
        
        # 创建数据透视表工作表
        ws_pivot = wb.sheets.add('数据透视表')
        
        # 创建数据透视表缓存
        pivot_cache = wb.api.PivotCaches().Create(
            SourceType=1,  # xlDatabase
            SourceData=ws_data.range('A1').current_region.api
        )
        
        # 创建数据透视表
        pivot_table = pivot_cache.CreatePivotTable(
            TableDestination=ws_pivot.range('A1').api,
            TableName='SalesPivotTable'
        )
        
        # 配置数据透视表字段
        pivot_table.PivotFields('区域').Orientation = 1  # xlRowField
        pivot_table.PivotFields('季度').Orientation = 1  # xlRowField
        pivot_table.PivotFields('产品').Orientation = 1  # xlRowField
        pivot_table.PivotFields('销售额').Orientation = 4  # xlDataField
        
        # 保存工作簿
        wb.save('自动化报表.xlsx')
        
        print("Excel自动化完成，文件已保存")
        
        # 等待用户查看
        input("按Enter键关闭Excel...")
        
    except Exception as e:
        print(f"自动化过程中出现错误: {e}")
    
    finally:
        # 关闭Excel应用程序
        app.quit()

def real_time_data_update():
    """实时数据更新示例"""
    app = xw.App(visible=True)
    
    try:
        wb = app.books.add()
        ws = wb.sheets[0]
        
        # 模拟实时数据更新
        for i in range(1, 11):
            # 更新单元格值
            ws.range(f'A{i}').value = f'数据点 {i}'
            ws.range(f'B{i}').value = i * 100
            ws.range(f'C{i}').value = f'=B{i}*1.1'  # 使用Excel公式
            
            # 强制Excel重新计算
            wb.app.calculate()
            
            print(f"更新第 {i} 行数据")
            time.sleep(1)  # 模拟实时更新间隔
        
        wb.save('实时数据.xlsx')
        
    finally:
        app.quit()

# 使用示例
if __name__ == "__main__":
    excel_automation_with_xlwings()
    # real_time_data_update()

三、库功能对比分析

3.1 Word处理库对比

库名称	优点	缺点	适用场景
python-docx	官方风格、功能全面、文档完善	不支持.doc格式、模板功能有限	程序化生成Word文档
docxtpl	强大的模板功能、支持条件逻辑	依赖python-docx、学习曲线稍陡	基于模板的动态文档生成
pywin32	完整Office自动化、支持VBA	仅Windows平台、依赖Office安装	复杂的Office自动化任务

3.2 Excel处理库对比

库名称	优点	缺点	适用场景
openpyxl	纯Python、无需Excel、功能丰富	处理大文件较慢、不支持.xls	创建复杂格式的Excel文件
pandas	数据处理能力强、API简洁	样式控制有限、依赖其他库	数据分析和处理
xlwings	与Excel交互、支持VBA	需要安装Excel、Windows为主	Excel自动化和交互操作
xlsxwriter	性能优秀、样式控制精细	只能创建不能读取	生成大型报表

四、最佳实践与注意事项

4.1 性能优化策略

import time
from functools import wraps

def performance_monitor(func):
    """性能监控装饰器"""
    @wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"{func.__name__} 执行时间: {end_time - start_time:.2f}秒")
        return result
    return wrapper

@performance_monitor
def optimize_large_excel_operations():
    """优化大型Excel操作"""
    
    # 1. 使用生成器避免内存溢出
    def large_data_generator():
        for i in range(10000):
            yield [f'数据{i}', i * 100, f'描述{i}']
    
    # 2. 批量写入数据
    wb = Workbook()
    ws = wb.active
    
    # 分批写入数据
    batch_size = 1000
    current_row = 1
    
    for i, row_data in enumerate(large_data_generator()):
        for col, value in enumerate(row_data, 1):
            ws.cell(row=current_row, column=col, value=value)
        
        # 每1000行保存一次
        if i % batch_size == 0:
            wb.save(f'temp_batch_{i}.xlsx')
            print(f"已处理 {i} 行数据")
        
        current_row += 1
    
    wb.save('优化后的大文件.xlsx')

4.2 错误处理与日志记录

import logging
from pathlib import Path

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler('document_processing.log'),
        logging.StreamHandler()
    ]
)

class DocumentProcessor:
    """文档处理器基类"""
    
    def __init__(self):
        self.logger = logging.getLogger(__name__)
    
    def safe_document_operation(self, operation_func, file_path, *args, **kwargs):
        """安全的文档操作包装器"""
        try:
            # 检查文件路径
            if not Path(file_path).exists():
                raise FileNotFoundError(f"文件不存在: {file_path}")
            
            # 检查文件扩展名
            if not self.validate_file_extension(file_path):
                raise ValueError(f"不支持的文件格式: {file_path}")
            
            # 执行操作
            result = operation_func(file_path, *args, **kwargs)
            self.logger.info(f"文档操作成功: {file_path}")
            return result
            
        except PermissionError as e:
            self.logger.error(f"文件权限错误: {e}")
            raise
        except Exception as e:
            self.logger.error(f"文档操作失败: {e}")
            raise
    
    def validate_file_extension(self, file_path):
        """验证文件扩展名"""
        valid_extensions = {'.docx', '.xlsx', '.xls'}
        return Path(file_path).suffix.lower() in valid_extensions

class ExcelProcessor(DocumentProcessor):
    """Excel处理器"""
    
    def read_large_excel(self, file_path, chunk_size=1000):
        """分块读取大型Excel文件"""
        def read_operation(file_path):
            results = []
            chunk_number = 0
            
            # 使用pandas分块读取
            for chunk in pd.read_excel(file_path, chunksize=chunk_size):
                chunk_number += 1
                results.append({
                    'chunk': chunk_number,
                    'rows': len(chunk),
                    'columns': list(chunk.columns),
                    'sample_data': chunk.head(3).to_dict('records')
                })
                self.logger.info(f"读取第 {chunk_number} 块数据，{len(chunk)} 行")
            
            return results
        
        return self.safe_document_operation(read_operation, file_path)

# 使用示例
processor = ExcelProcessor()
try:
    results = processor.read_large_excel('大型数据文件.xlsx')
    print(f"成功读取 {len(results)} 个数据块")
except Exception as e:
    print(f"处理失败: {e}")

4.3 配置管理与环境设置

import os
from dataclasses import dataclass
from typing import Dict, Any

@dataclass
class DocumentConfig:
    """文档处理配置"""
    
    # 文件路径配置
    input_dir: str = './input'
    output_dir: str = './output'
    temp_dir: str = './temp'
    
    # Excel配置
    excel_engine: str = 'openpyxl'
    default_sheet_name: str = 'Sheet1'
    max_rows_per_sheet: int = 1000000
    
    # Word配置
    default_font: str = '微软雅黑'
    default_font_size: int = 11
    
    # 性能配置
    chunk_size: int = 1000
    enable_compression: bool = True
    
    @classmethod
    def from_env(cls):
        """从环境变量加载配置"""
        return cls(
            input_dir=os.getenv('DOC_INPUT_DIR', './input'),
            output_dir=os.getenv('DOC_OUTPUT_DIR', './output'),
            excel_engine=os.getenv('EXCEL_ENGINE', 'openpyxl'),
            chunk_size=int(os.getenv('CHUNK_SIZE', '1000'))
        )
    
    def create_directories(self):
        """创建必要的目录"""
        for directory in [self.input_dir, self.output_dir, self.temp_dir]:
            os.makedirs(directory, exist_ok=True)
    
    def validate(self):
        """验证配置"""
        if self.excel_engine not in ['openpyxl', 'xlwings', 'xlsxwriter']:
            raise ValueError(f"不支持的Excel引擎: {self.excel_engine}")
        
        if self.max_rows_per_sheet > 1048576:  # Excel最大行数
            raise ValueError("每sheet最大行数超出Excel限制")

# 使用配置
config = DocumentConfig.from_env()
config.create_directories()

try:
    config.validate()
    print("配置验证通过")
except ValueError as e:
    print(f"配置错误: {e}")

五、企业级应用架构

5.1 文档处理流水线

from abc import ABC, abstractmethod
from typing import List, Dict, Any
import pandas as pd

class DocumentProcessorPipeline:
    """文档处理流水线"""
    
    def __init__(self):
        self.processors = []
    
    def add_processor(self, processor):
        """添加处理器"""
        self.processors.append(processor)
    
    def process(self, input_file: str, output_file: str) -> Dict[str, Any]:
        """执行处理流水线"""
        results = {
            'input_file': input_file,
            'output_file': output_file,
            'steps': [],
            'errors': []
        }
        
        current_data = None
        
        for i, processor in enumerate(self.processors, 1):
            try:
                step_result = processor.process(input_file, current_data)
                results['steps'].append({
                    'step': i,
                    'processor': processor.__class__.__name__,
                    'status': 'success',
                    'result': step_result
                })
                current_data = step_result.get('data', current_data)
                
            except Exception as e:
                error_info = {
                    'step': i,
                    'processor': processor.__class__.__name__,
                    'error': str(e),
                    'status': 'failed'
                }
                results['errors'].append(error_info)
                results['steps'].append(error_info)
                break
        
        # 保存最终结果
        if current_data is not None and not results['errors']:
            self.save_results(current_data, output_file)
            results['final_status'] = 'success'
        else:
            results['final_status'] = 'failed'
        
        return results
    
    def save_results(self, data, output_file):
        """保存处理结果"""
        if isinstance(data, pd.DataFrame):
            data.to_excel(output_file, index=False)
        else:
            # 其他数据类型的保存逻辑
            pass

class BaseProcessor(ABC):
    """处理器基类"""
    
    @abstractmethod
    def process(self, input_file: str, previous_data: Any) -> Dict[str, Any]:
        pass

class ExcelReaderProcessor(BaseProcessor):
    """Excel读取处理器"""
    
    def process(self, input_file: str, previous_data: Any) -> Dict[str, Any]:
        df = pd.read_excel(input_file)
        return {
            'data': df,
            'summary': {
                'rows': len(df),
                'columns': len(df.columns),
                'memory_usage': df.memory_usage(deep=True).sum()
            }
        }

class DataCleanProcessor(BaseProcessor):
    """数据清洗处理器"""
    
    def process(self, input_file: str, previous_data: Any) -> Dict[str, Any]:
        if previous_data is None:
            raise ValueError("没有输入数据")
        
        df = previous_data['data']
        
        # 执行数据清洗
        df_clean = df.dropna()  # 删除空值
        df_clean = df_clean.drop_duplicates()  # 删除重复值
        
        return {
            'data': df_clean,
            'cleaning_stats': {
                'original_rows': len(df),
                'cleaned_rows': len(df_clean),
                'removed_rows': len(df) - len(df_clean)
            }
        }

# 使用流水线
pipeline = DocumentProcessorPipeline()
pipeline.add_processor(ExcelReaderProcessor())
pipeline.add_processor(DataCleanProcessor())

results = pipeline.process('原始数据.xlsx', '清洗后数据.xlsx')
print("处理结果:", results)