• 🌸 欢迎来到Python办公自动化专栏—Python处理办公问题，解放您的双

• 💻 个人主页——>个人主页欢迎访问

• 😸 Github主页——>Github主页欢迎访问

• ❓ 知乎主页——>知乎主页欢迎访问

• 🏳️‍🌈 CSDN博客主页：请点击——> 一晌小贪欢的博客主页求关注

• 👍 该系列文章专栏：请点击——>Python办公自动化专栏求订阅

• 🕷 此外还有爬虫专栏：请点击——>Python爬虫基础专栏求订阅

• 📕 此外还有python基础专栏：请点击——>Python基础学习专栏求订阅

• 文章作者技术和水平有限，如果文中出现错误，希望大家能指正🙏

• ❤️ 欢迎各位佬关注！ ❤️

前言

在日常办公自动化中，Excel文件处理是一个非常常见的需求。传统的pandas读取Excel文件虽然功能强大，但在处理大型Excel文件时往往性能不佳，内存占用高。今天给大家介绍一个高性能的Excel读取库——Python Calamine，它基于Rust开发，读取速度比pandas快数倍，是处理大型Excel文件的利器！

Python Calamine 简介

什么是 Python Calamine？

Python Calamine 是一个基于 Rust 的 Excel 文件读取库，专门为高性能数据处理而设计。它具有以下显著优势：

🚀 核心优势

1. 超高性能：基于Rust开发，读取速度比pandas快3-10倍
2. 低内存占用：内存使用效率极高，适合处理大型Excel文件
3. 简单易用：API设计简洁，学习成本低
4. 多格式支持：支持.xlsx、.xlsm、.xlsb等多种Excel格式
5. 跨平台兼容：支持Windows、macOS、Linux等多个平台

📊 性能对比

安装方法

pip install python-calamine

单sheet读取详解

基础用法示例

下面是一个完整的单sheet读取示例，展示了如何高效处理Excel数据：

import os
import time
import python_calamine

def read_single_sheet_demo():
    """
    单sheet读取演示
    功能：读取Excel文件中的指定工作表，并进行数据统计
    """
    # 设置数据源路径
    base_dir = './数据源合并结果/'
  
    # 获取第一个Excel文件
    file_name = os.listdir(base_dir)[0]
    file_path = os.path.join(base_dir, file_name)
  
    print(f"正在处理文件：{file_name}")
    start_time = time.time()
  
    # 使用with语句确保文件正确关闭
    with open(file_path, 'rb') as f_r:
        # 创建Calamine工作簿对象
        xls = python_calamine.CalamineWorkbook.from_filelike(f_r)
    
        # 读取指定工作表并转换为Python数据结构
        sheet = xls.get_sheet_by_name('OrderOutboundCargo').to_python()
  
    # 数据处理：提取表头和目标列索引
    head = sheet[0]  # 第一行作为表头
    SKU_index = head.index('SKU')  # 获取SKU列的索引位置
  
    # 高效去重：使用集合进行SKU去重统计
    set_sku = set()
    for row in sheet[1:]:  # 跳过表头行
        if row[SKU_index] not in set_sku:
            set_sku.add(row[SKU_index])
  
    # 转换为列表便于后续处理
    list_sku = list(set_sku)
  
    # 输出统计结果
    end_time = time.time()
    print(f"📊 聚合统计：{len(sheet)}个订单，{len(set_sku)}个唯一SKU")
    print(f"⏱️ {file_name} 加载完毕，耗时：{end_time - start_time:.2f} 秒")
  
    return list_sku, sheet

# 调用示例
if __name__ == "__main__":
    sku_list, data = read_single_sheet_demo()

代码详解

1. 文件读取方式

# 推荐使用二进制模式读取
with open(file_path, 'rb') as f_r:
    xls = python_calamine.CalamineWorkbook.from_filelike(f_r)

2. 工作表获取方法

# 方法一：按名称获取工作表
sheet = xls.get_sheet_by_name('OrderOutboundCargo').to_python()

# 方法二：按索引获取工作表
sheet = xls.get_sheet_by_index(0).to_python()

3. 数据结构说明

• sheet 是一个二维列表，每个元素代表一行数据
• sheet[0] 通常是表头行
• sheet[1:] 是实际数据行

多sheet读取详解

完整示例代码

# -*- coding: UTF-8 -*-
"""
多sheet读取演示
作者：一晌小贪欢
功能：批量读取Excel文件中的所有工作表
"""
import os
import time
import python_calamine

def read_multiple_sheets_demo():
    """
    多sheet批量读取演示
    功能：遍历文件夹中的所有Excel文件，读取每个文件的所有工作表
    """
    data_dir = "./数据源/"
  
    # 遍历数据源文件夹中的所有文件
    for file_name in os.listdir(data_dir):
        if not file_name.endswith(('.xlsx', '.xlsm', '.xlsb')):
            continue  # 跳过非Excel文件
        
        print(f"\n🔄 正在处理文件：{file_name}")
        start_time = time.time()
    
        file_path = os.path.join(data_dir, file_name)
    
        try:
            # 打开Excel文件
            with open(file_path, 'rb') as f_r:
                xls = python_calamine.CalamineWorkbook.from_filelike(f_r)
            
                # 获取所有工作表名称
                sheet_names = xls.sheet_names
                print(f"📋 发现 {len(sheet_names)} 个工作表：{sheet_names}")
            
                # 遍历每个工作表
                for sheet_index, sheet_name in enumerate(sheet_names):
                    print(f"\n📄 正在读取工作表：{sheet_name}")
                
                    # 获取工作表数据
                    rows = iter(xls.get_sheet_by_index(sheet_index).to_python())
                
                    # 处理表头
                    try:
                        head = list(map(str, next(rows)))
                        print(f"📊 表头：{head[:5]}...")  # 只显示前5列
                    
                        # 可选：跳过指定行数（如果Excel有特殊格式）
                        # for _ in range(8):  # 跳过前8行
                        #     next(rows)
                        # head = list(map(str, next(rows)))  # 获取第9行作为表头
                    
                        # 处理数据行
                        row_count = 0
                        for row in rows:
                            # 这里可以添加具体的数据处理逻辑
                            # print(row)  # 打印每一行数据
                            row_count += 1
                        
                            # 为了演示，只处理前10行
                            if row_count >= 10:
                                print(f"... (共处理了 {row_count} 行数据)")
                                break
                            
                    except StopIteration:
                        print("⚠️ 工作表为空或无数据")
                    
        except Exception as e:
            print(f"❌ 处理文件 {file_name} 时出错：{str(e)}")
            continue
        
        # 计算处理时间
        end_time = time.time()
        print(f"✅ {file_name} 处理完毕，耗时：{end_time - start_time:.2f} 秒")

# 高级用法：指定工作表处理
def process_specific_sheets():
    """
    处理指定的工作表
    """
    file_path = "./数据源/示例文件.xlsx"
    target_sheets = ['Sheet1', 'Data', 'Summary']  # 指定要处理的工作表
  
    with open(file_path, 'rb') as f_r:
        xls = python_calamine.CalamineWorkbook.from_filelike(f_r)
    
        for sheet_name in target_sheets:
            if sheet_name in xls.sheet_names:
                sheet_data = xls.get_sheet_by_name(sheet_name).to_python()
                print(f"处理工作表 {sheet_name}，共 {len(sheet_data)} 行数据")
                # 添加具体处理逻辑
            else:
                print(f"⚠️ 工作表 {sheet_name} 不存在")

if __name__ == "__main__":
    read_multiple_sheets_demo()

多sheet读取要点

1. 工作表名称获取

# 获取所有工作表名称
sheet_names = xls.sheet_names
print(f"工作表列表：{sheet_names}")

2. 迭代器使用技巧

# 使用迭代器可以节省内存
rows = iter(xls.get_sheet_by_index(sheet_index).to_python())
head = next(rows)  # 获取表头

3. 异常处理

try:
    # Excel读取操作
    pass
except StopIteration:
    print("工作表为空")
except Exception as e:
    print(f"读取出错：{e}")

性能优化技巧

1. 内存优化

# 使用迭代器而不是一次性加载所有数据
def memory_efficient_reading(file_path, sheet_name):
    with open(file_path, 'rb') as f_r:
        xls = python_calamine.CalamineWorkbook.from_filelike(f_r)
        rows = iter(xls.get_sheet_by_name(sheet_name).to_python())
    
        # 逐行处理，避免内存溢出
        for row in rows:
            # 处理单行数据
            process_row(row)

def process_row(row):
    # 具体的行处理逻辑
    pass

2. 批量处理优化

def batch_process_excel_files(directory, batch_size=100):
    """
    批量处理Excel文件，避免内存溢出
    """
    files = [f for f in os.listdir(directory) if f.endswith('.xlsx')]
  
    for i in range(0, len(files), batch_size):
        batch_files = files[i:i+batch_size]
    
        for file_name in batch_files:
            # 处理单个文件
            process_single_file(os.path.join(directory, file_name))
        
        # 可选：在批次之间进行垃圾回收
        import gc
        gc.collect()

3. 性能对比测试

import time
import pandas as pd
import python_calamine

def performance_comparison(file_path):
    """
    性能对比测试：Calamine vs Pandas
    """
    print("🔄 开始性能对比测试...")
  
    # 测试 Calamine
    start_time = time.time()
    with open(file_path, 'rb') as f_r:
        xls = python_calamine.CalamineWorkbook.from_filelike(f_r)
        sheet = xls.get_sheet_by_index(0).to_python()
    calamine_time = time.time() - start_time
  
    # 测试 Pandas
    start_time = time.time()
    df = pd.read_excel(file_path)
    pandas_time = time.time() - start_time
  
    # 输出对比结果
    print(f"📊 性能对比结果：")
    print(f"   Calamine 耗时：{calamine_time:.2f} 秒")
    print(f"   Pandas 耗时：{pandas_time:.2f} 秒")
    print(f"   性能提升：{pandas_time/calamine_time:.1f}x")

实际应用场景

1. 大型数据文件处理

def handle_large_excel_file(file_path, output_path):
    """
    处理大型Excel文件，提取关键信息并输出
    """
    result_data = []
  
    with open(file_path, 'rb') as f_r:
        xls = python_calamine.CalamineWorkbook.from_filelike(f_r)
        rows = iter(xls.get_sheet_by_index(0).to_python())
    
        # 获取表头
        headers = next(rows)
    
        # 逐行处理数据
        for row_num, row in enumerate(rows, 1):
            # 数据清洗和处理
            processed_row = clean_and_process_row(row, headers)
            if processed_row:
                result_data.append(processed_row)
        
            # 每处理1000行显示一次进度
            if row_num % 1000 == 0:
                print(f"已处理 {row_num} 行数据...")
  
    # 保存处理结果
    save_results(result_data, output_path)
    print(f"✅ 处理完成，共处理 {len(result_data)} 行有效数据")

def clean_and_process_row(row, headers):
    """
    数据清洗和处理函数
    """
    # 添加具体的数据清洗逻辑
    return row

2. 多文件合并处理

def merge_multiple_excel_files(input_dir, output_file):
    """
    合并多个Excel文件到一个文件中
    """
    all_data = []
    headers = None
  
    for file_name in os.listdir(input_dir):
        if not file_name.endswith('.xlsx'):
            continue
        
        file_path = os.path.join(input_dir, file_name)
        print(f"正在处理：{file_name}")
    
        with open(file_path, 'rb') as f_r:
            xls = python_calamine.CalamineWorkbook.from_filelike(f_r)
            sheet_data = xls.get_sheet_by_index(0).to_python()
        
            if headers is None:
                headers = sheet_data[0]  # 保存表头
            
            # 添加数据行（跳过表头）
            all_data.extend(sheet_data[1:])
  
    # 保存合并结果
    merged_data = [headers] + all_data
    save_to_excel(merged_data, output_file)
    print(f"✅ 合并完成，共 {len(all_data)} 行数据")

注意事项与最佳实践

⚠️ 注意事项

1. 文件格式支持：主要支持.xlsx、.xlsm、.xlsb格式，不支持老版本的.xls格式
2. 内存管理：虽然内存效率高，但处理超大文件时仍需注意内存使用
3. 错误处理：建议添加完善的异常处理机制
4. 编码问题：使用二进制模式读取文件，避免编码问题

🎯 最佳实践

1. 文件读取模式

# ✅ 推荐：使用with语句和二进制模式
with open(file_path, 'rb') as f_r:
    xls = python_calamine.CalamineWorkbook.from_filelike(f_r)

# ❌ 不推荐：直接使用文件路径（可能有编码问题）

2. 数据类型处理

# 处理不同数据类型
def safe_convert_data(value):
    """安全的数据类型转换"""
    if value is None:
        return ""
    elif isinstance(value, (int, float)):
        return value
    else:
        return str(value).strip()

3. 进度监控

def read_with_progress(file_path, sheet_name):
    """带进度显示的读取函数"""
    with open(file_path, 'rb') as f_r:
        xls = python_calamine.CalamineWorkbook.from_filelike(f_r)
        rows = iter(xls.get_sheet_by_name(sheet_name).to_python())
    
        total_rows = len(xls.get_sheet_by_name(sheet_name).to_python())
    
        for i, row in enumerate(rows):
            # 显示进度
            if i % 1000 == 0:
                progress = (i / total_rows) * 100
                print(f"进度：{progress:.1f}% ({i}/{total_rows})")
        
            # 处理数据
            process_row(row)

总结

🎉 Python Calamine 的优势总结

1. 🚀 超高性能：比传统的pandas读取速度快3-10倍
2. 💾 低内存占用：内存使用效率极高，适合大型文件处理
3. 🔧 简单易用：API设计简洁，学习成本低
4. 📊 功能完善：支持单sheet和多sheet读取，满足各种需求
5. 🛡️ 稳定可靠：基于Rust开发，性能稳定

📈 适用场景

• 大型Excel文件处理：文件大小超过100MB的Excel文件
• 批量数据处理：需要处理大量Excel文件的场景
• 实时数据分析：对读取速度有较高要求的应用
• 内存受限环境：服务器内存有限的生产环境

🔮 未来展望

Python Calamine作为一个高性能的Excel读取库，在办公自动化领域有着广阔的应用前景。随着数据量的不断增长，这种高性能的数据处理工具将变得越来越重要。

• 希望对初学者有帮助；致力于办公自动化的小小程序员一枚

• 希望能得到大家的【❤️一个免费关注❤️】感谢！

• 求个 🤞 关注 🤞 +❤️ 喜欢 ❤️ +👍 收藏 👍

• 此外还有办公自动化专栏，欢迎大家订阅：Python办公自动化专栏

• 此外还有爬虫专栏，欢迎大家订阅：Python爬虫基础专栏

• 此外还有Python基础专栏，欢迎大家订阅：Python基础学习专栏