从原理到实战详解Python如何高效清理Excel空白行列

pip install openpyxl

from openpyxl import load_workbook

def clean_excel(file_path, output_path):
    """
    清理Excel文件中的空白行列
    :param file_path: 输入文件路径
    :param output_path: 输出文件路径
    """
    # 加载工作簿
    wb = load_workbook(filename=file_path)
    
    # 遍历所有工作表
    for sheet_name in wb.sheetnames:
        ws = wb[sheet_name]
        clean_sheet(ws)
    
    # 保存结果
    wb.save(output_path)
    print(f"处理完成，结果已保存至 {output_path}")

def clean_sheet(ws):
    """
    清理单个工作表中的空白行列
    :param ws: 工作表对象
    """
    # 获取最大行和最大列
    max_row = ws.max_row
    max_col = ws.max_column
    
    # 从下往上检查行（避免删除时索引变化）
    rows_to_delete = []
    for row in range(max_row, 0, -1):
        is_empty = True
        
        # 检查该行所有单元格
        for col in range(1, max_col + 1):
            cell = ws.cell(row=row, column=col)
            if cell.value is not None:
                is_empty = False
                break
        
        if is_empty:
            rows_to_delete.append(row)
    
    # 批量删除行（从下往上）
    for row in rows_to_delete:
        ws.delete_rows(row)
    
    # 接下来处理列（逻辑类似）
    clean_columns(ws)

def clean_columns(ws):
    """
    清理工作表中的空白列
    :param ws: 工作表对象
    """
    max_row = ws.max_row
    if max_row == 0:
        return  # 空工作表
    
    max_col = ws.max_column
    cols_to_delete = []
    
    # 从右往左检查列
    for col in range(max_col, 0, -1):
        is_empty = True
        
        # 检查该列所有单元格
        for row in range(1, max_row + 1):
            cell = ws.cell(row=row, column=col)
            if cell.value is not None:
                is_empty = False
                break
        
        if is_empty:
            cols_to_delete.append(col)
    
    # 批量删除列（从右往左）
    for col in cols_to_delete:
        ws.delete_cols(col)

from openpyxl import load_workbook

def clean_excel(file_path, output_path):
    """主清理函数"""
    wb = load_workbook(filename=file_path)
    
    for sheet_name in wb.sheetnames:
        ws = wb[sheet_name]
        clean_sheet(ws)
    
    wb.save(output_path)
    print(f"处理完成，结果已保存至 {output_path}")

def clean_sheet(ws):
    """清理单个工作表"""
    # 清理空白行
    max_row = ws.max_row
    max_col = ws.max_column
    
    # 从下往上检查行
    rows_to_delete = []
    for row in range(max_row, 0, -1):
        if all(ws.cell(row=row, column=col).value is None 
               for col in range(1, max_col + 1)):
            rows_to_delete.append(row)
    
    for row in sorted(rows_to_delete, reverse=True):
        ws.delete_rows(row)
    
    # 更新最大列数（因为行删除可能影响列判断）
    max_col = ws.max_column
    if max_col == 0:
        return
    
    # 清理空白列
    cols_to_delete = []
    for col in range(max_col, 0, -1):
        if all(ws.cell(row=row, column=col).value is None 
               for row in range(1, ws.max_row + 1)):
            cols_to_delete.append(col)
    
    for col in sorted(cols_to_delete, reverse=True):
        ws.delete_cols(col)

# 使用示例
if __name__ == "__main__":
    input_file = "input.xlsx"
    output_file = "output.xlsx"
    clean_excel(input_file, output_file)

# 优化后的行删除（示例）
def delete_rows_optimized(ws, rows_to_delete):
    """批量删除多行"""
    # 按从大到小排序
    rows_sorted = sorted(rows_to_delete, reverse=True)
    offset = 0
    for row in rows_sorted:
        ws.delete_rows(row - offset)
        offset += 1

from concurrent.futures import ThreadPoolExecutor

def parallel_clean(file_path, output_path, max_workers=4):
    wb = load_workbook(filename=file_path)
    
    def process_sheet(sheet_name):
        ws = wb[sheet_name]
        clean_sheet(ws)
        return ws
    
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        list(executor.map(process_sheet, wb.sheetnames))
    
    wb.save(output_path)

def is_cell_empty(ws, row, col):
    """检查单元格是否为空，考虑合并单元格"""
    cell = ws.cell(row=row, column=col)
    if cell.value is not None:
        return False
    
    # 检查是否属于合并单元格区域
    for merge_range in ws.merged_cells.ranges:
        if (row, col) in merge_range.cells:
            # 合并区域中只要有一个单元格有值就不算空
            for r in range(merge_range.min_row, merge_range.max_row + 1):
                for c in range(merge_range.min_col, merge_range.max_col + 1):
                    if ws.cell(row=r, column=c).value is not None:
                        return False
            return True  # 合并区域所有单元格都为空
    
    return True

def is_cell_really_empty(ws, row, col):
    """严格检查单元格是否为空（包括公式）"""
    cell = ws.cell(row=row, column=col)
    return cell.value is None and cell.data_type == 'n'  # 'n'表示无数据类型

from openpyxl.styles import Font, Border, PatternFill

def copy_style(source_cell, target_cell):
    """复制单元格样式"""
    if source_cell.has_style:
        target_cell.font = copy(source_cell.font)
        target_cell.border = copy(source_cell.border)
        target_cell.fill = copy(source_cell.fill)
        target_cell.number_format = copy(source_cell.number_format)
        target_cell.protection = copy(source_cell.protection)
        target_cell.alignment = copy(source_cell.alignment)

from openpyxl import load_workbook
from openpyxl.utils import range_boundaries
from copy import copy

def clean_excel_advanced(file_path, output_path, 
                        handle_merged=True, 
                        preserve_formatting=False):
    """
    高级Excel清理函数
    :param file_path: 输入文件路径
    :param output_path: 输出文件路径
    :param handle_merged: 是否处理合并单元格
    :param preserve_formatting: 是否保留格式
    """
    wb = load_workbook(filename=file_path)
    
    for sheet_name in wb.sheetnames:
        ws = wb[sheet_name]
        clean_sheet_advanced(ws, handle_merged, preserve_formatting)
    
    wb.save(output_path)
    print(f"高级处理完成，结果已保存至 {output_path}")

def clean_sheet_advanced(ws, handle_merged=True, preserve_formatting=False):
    """高级工作表清理"""
    # 1. 处理空白行
    max_row = ws.max_row
    max_col = ws.max_column
    
    rows_to_delete = []
    for row in range(max_row, 0, -1):
        is_empty = True
        
        for col in range(1, max_col + 1):
            if not is_cell_empty(ws, row, col, handle_merged):
                is_empty = False
                break
        
        if is_empty:
            rows_to_delete.append(row)
    
    # 批量删除行
    for row in sorted(rows_to_delete, reverse=True):
        ws.delete_rows(row)
    
    # 更新最大列
    max_col = ws.max_column
    if max_col == 0:
        return
    
    # 2. 处理空白列
    cols_to_delete = []
    for col in range(max_col, 0, -1):
        is_empty = True
        
        for row in range(1, ws.max_row + 1):
            if not is_cell_empty(ws, row, col, handle_merged):
                is_empty = False
                break
        
        if is_empty:
            cols_to_delete.append(col)
    
    # 批量删除列
    for col in sorted(cols_to_delete, reverse=True):
        ws.delete_cols(col)

def is_cell_empty(ws, row, col, handle_merged=True):
    """检查单元格是否为空"""
    cell = ws.cell(row=row, column=col)
    if cell.value is not None:
        return False
    
    if handle_merged:
        for merge_range in ws.merged_cells.ranges:
            min_col, min_row, max_col, max_row = range_boundaries(str(merge_range))
            if (row >= min_row and row <= max_row and 
                col >= min_col and col <= max_col):
                # 检查合并区域是否有值
                for r in range(min_row, max_row + 1):
                    for c in range(min_col, max_col + 1):
                        if ws.cell(row=r, column=c).value is not None:
                            return False
                return True
    
    return True

# 使用示例
if __name__ == "__main__":
    input_file = "complex_input.xlsx"
    output_file = "cleaned_output.xlsx"
    clean_excel_advanced(
        input_file, 
        output_file,
        handle_merged=True,
        preserve_formatting=False
    )