使用pandas轻松实现多种格式文件的读取与写入操作从CSV到Excel全面掌握数据处理必备技能

威震华夏关云长 · 发表于 2025-8-27 10:00:00

马上注册，结交更多好友，享用更多功能，让你轻松玩转社区。

您需要登录才可以下载或查看，没有账号？立即注册

x

引言

在数据科学和分析领域，文件读取与写入是数据处理流程中不可或缺的基础环节。Python的pandas库作为数据分析的核心工具，提供了强大而灵活的文件I/O功能，使数据科学家能够轻松处理各种格式的数据文件。无论是简单的CSV文件，还是复杂的Excel工作簿，pandas都能提供简洁高效的解决方案。本文将全面介绍如何使用pandas实现多种格式文件的读取与写入操作，帮助您掌握这一数据处理必备技能，提高工作效率。

CSV文件操作

CSV（Comma-Separated Values，逗号分隔值）是最常见的数据交换格式之一，因其简单性和通用性被广泛使用。pandas提供了read_csv()和to_csv()两个核心函数来处理CSV文件。

读取CSV文件

使用pd.read_csv()函数可以轻松读取CSV文件：

import pandas as pd
# 基本读取
df = pd.read_csv('data.csv')
# 查看前5行数据
print(df.head())

复制代码

read_csv()函数提供了丰富的参数来应对各种情况：

# 指定分隔符（默认为逗号）
df = pd.read_csv('data.tsv', sep='\t') # 读取TSV文件
# 指定编码（处理中文等非ASCII字符）
df = pd.read_csv('data.csv', encoding='utf-8')
df = pd.read_csv('data.csv', encoding='gbk') # 中文Windows常用编码
# 指定列名
df = pd.read_csv('data.csv', names=['列1', '列2', '列3']) # 自定义列名
df = pd.read_csv('data.csv', header=0) # 使用第一行作为列名（默认）
df = pd.read_csv('data.csv', header=None) # 没有列名
# 指定索引列
df = pd.read_csv('data.csv', index_col='id') # 使用'id'列作为索引
df = pd.read_csv('data.csv', index_col=0) # 使用第一列作为索引
# 只读取部分列
df = pd.read_csv('data.csv', usecols=['列1', '列3']) # 只读取指定列
df = pd.read_csv('data.csv', usecols=[0, 2]) # 只读取第1和第3列
# 跳过行
df = pd.read_csv('data.csv', skiprows=2) # 跳过前2行
df = pd.read_csv('data.csv', skiprows=[1, 3]) # 跳过第2和第4行
# 处理缺失值
df = pd.read_csv('data.csv', na_values=['NA', 'N/A', 'null', 'NaN']) # 指定哪些值视为缺失值
# 指定数据类型
df = pd.read_csv('data.csv', dtype={'列1': 'int64', '列2': 'float64'})
# 解析日期
df = pd.read_csv('data.csv', parse_dates=['日期列']) # 将指定列解析为日期
df = pd.read_csv('data.csv', parse_dates=True) # 尝试解析所有可能的日期列
# 处理大文件 - 分块读取
chunk_iter = pd.read_csv('large_data.csv', chunksize=10000) # 每次读取10000行
for chunk in chunk_iter:
process(chunk) # 处理每个数据块

复制代码

写入CSV文件

使用DataFrame的to_csv()方法可以将数据写入CSV文件：

import pandas as pd
# 创建一个示例DataFrame
data = {
'姓名': ['张三', '李四', '王五'],
'年龄': [25, 30, 35],
'城市': ['北京', '上海', '广州']
}
df = pd.DataFrame(data)
# 基本写入
df.to_csv('output.csv')
# 不写入索引
df.to_csv('output.csv', index=False)
# 指定分隔符
df.to_csv('output.tsv', sep='\t') # 写入为TSV文件
# 指定编码
df.to_csv('output.csv', encoding='utf-8')
df.to_csv('output.csv', encoding='gbk') # 中文Windows常用编码
# 处理缺失值表示
df.to_csv('output.csv', na_rep='NULL') # 将缺失值表示为'NULL'
# 只写入部分列
df.to_csv('output.csv', columns=['姓名', '城市'])
# 指定浮点数格式
df['浮点数列'] = [3.1415926, 2.7182818, 1.4142135]
df.to_csv('output.csv', float_format='%.2f') # 保留两位小数
# 处理日期格式
df['日期'] = pd.date_range('2023-01-01', periods=3)
df.to_csv('output.csv', date_format='%Y-%m-%d') # 指定日期格式
# 压缩输出
df.to_csv('output.csv.gz', compression='gzip') # 输出为gzip压缩文件

复制代码

Excel文件操作

Excel文件是商业和科研领域常用的数据存储格式，特别是当数据包含多个工作表或需要格式化时。pandas通过read_excel()和to_excel()函数支持Excel文件操作。

读取Excel文件

使用pd.read_excel()函数读取Excel文件：

import pandas as pd
# 基本读取
df = pd.read_excel('data.xlsx')
# 指定工作表
df = pd.read_excel('data.xlsx', sheet_name='Sheet1') # 按名称指定
df = pd.read_excel('data.xlsx', sheet_name=0) # 按索引指定（第一个工作表）
# 读取多个工作表
all_sheets = pd.read_excel('data.xlsx', sheet_name=None) # 返回所有工作表的字典
for sheet_name, df in all_sheets.items():
print(f"工作表名: {sheet_name}")
print(df.head())
# 指定列名和索引
df = pd.read_excel('data.xlsx', header=0) # 使用第一行作为列名（默认）
df = pd.read_excel('data.xlsx', header=None) # 没有列名
df = pd.read_excel('data.xlsx', index_col='id') # 使用'id'列作为索引
# 只读取部分列
df = pd.read_excel('data.xlsx', usecols=['列1', '列3']) # 只读取指定列
df = pd.read_excel('data.xlsx', usecols=[0, 2]) # 只读取第1和第3列
# 跳过行
df = pd.read_excel('data.xlsx', skiprows=2) # 跳过前2行
df = pd.read_excel('data.xlsx', skiprows=[1, 3]) # 跳过第2和第4行
# 指定数据类型
df = pd.read_excel('data.xlsx', dtype={'列1': 'int64', '列2': 'float64'})

复制代码

写入Excel文件

使用DataFrame的to_excel()方法将数据写入Excel文件：

import pandas as pd
# 创建示例DataFrame
data = {
'姓名': ['张三', '李四', '王五'],
'年龄': [25, 30, 35],
'城市': ['北京', '上海', '广州']
}
df = pd.DataFrame(data)
# 基本写入
df.to_excel('output.xlsx')
# 不写入索引
df.to_excel('output.xlsx', index=False)
# 指定工作表名称
df.to_excel('output.xlsx', sheet_name='数据表')
# 写入到Excel文件的特定位置（单元格）
df.to_excel('output.xlsx', startrow=1, startcol=1) # 从B2单元格开始写入
# 写入多个工作表
with pd.ExcelWriter('multi_sheet.xlsx') as writer:
df1.to_excel(writer, sheet_name='数据1')
df2.to_excel(writer, sheet_name='数据2')
# 追加到现有Excel文件
with pd.ExcelWriter('existing.xlsx', mode='a', engine='openpyxl') as writer:
df.to_excel(writer, sheet_name='新数据')
# 处理日期格式
df['日期'] = pd.date_range('2023-01-01', periods=3)
df.to_excel('output.xlsx', date_format='YYYY-MM-DD')
# 设置列宽
with pd.ExcelWriter('output.xlsx', engine='xlsxwriter') as writer:
df.to_excel(writer, sheet_name='数据表', index=False)
# 获取工作表对象
worksheet = writer.sheets['数据表']
# 设置列宽
worksheet.set_column('A:A', 20) # A列宽度为20
worksheet.set_column('B:C', 15) # B到C列宽度为15
# 添加条件格式
with pd.ExcelWriter('output.xlsx', engine='xlsxwriter') as writer:
df.to_excel(writer, sheet_name='数据表', index=False)
workbook = writer.book
worksheet = writer.sheets['数据表']
# 添加条件格式 - 将年龄大于30的单元格标红
format1 = workbook.add_format({'bg_color': '#FFC7CE'})
worksheet.conditional_format('B2:B4', {'type': 'cell',
'criteria': '>',
'value': 30,
'format': format1})

复制代码

其他格式文件操作

除了CSV和Excel，pandas还支持多种其他数据格式的读写操作，下面介绍几种常用格式。

JSON文件操作

JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，常用于Web应用。

import pandas as pd
import json
# 读取JSON文件
df = pd.read_json('data.json')
# 从JSON字符串读取
json_str = '{"姓名": ["张三", "李四"], "年龄": [25, 30]}'
df = pd.read_json(json_str)
# 写入JSON文件
df.to_json('output.json')
# 指定JSON格式
df.to_json('output.json', orient='records') # 每行作为一个JSON对象
df.to_json('output.json', orient='split') # 分割格式
df.to_json('output.json', orient='index') # 索引格式
df.to_json('output.json', orient='values') # 只包含值，不包含索引和列名
# 处理嵌套JSON
# 假设有一个嵌套的JSON文件
nested_json = """
{
"employees": [
{"name": "张三", "age": 25, "contact": {"email": "zhangsan@example.com", "phone": "123456"}},
{"name": "李四", "age": 30, "contact": {"email": "lisi@example.com", "phone": "789012"}}
]
}
"""
# 使用json_normalize处理嵌套JSON
data = json.loads(nested_json)
df = pd.json_normalize(data['employees'])
print(df)

复制代码

HTML文件操作

pandas可以直接从HTML表格中读取数据，也可以将DataFrame转换为HTML表格。

import pandas as pd
# 从HTML读取表格
# 注意：需要安装lxml或html5lib库
# pip install lxml html5lib
# 读取HTML文件中的所有表格
tables = pd.read_html('data.html')
df = tables[0] # 获取第一个表格
# 从URL读取HTML表格
url = 'https://en.wikipedia.org/wiki/List_of_countries_by_population'
tables = pd.read_html(url)
df = tables[0] # 通常第一个表格是主要内容
# 将DataFrame写入HTML
df.to_html('output.html')
# 自定义HTML输出
df.to_html('output.html',
table_id='data_table', # 设置表格ID
classes='table table-striped', # 添加CSS类
escape=False, # 不转义HTML字符
render_links=True, # 渲染链接
index=False) # 不包含索引

复制代码

SQL数据库操作

pandas可以与SQL数据库进行交互，支持多种数据库引擎。

import pandas as pd
import sqlite3 # SQLite数据库
from sqlalchemy import create_engine # 支持多种数据库
# 连接到SQLite数据库
conn = sqlite3.connect('database.db')
# 从SQL查询读取数据
df = pd.read_sql('SELECT * FROM employees', conn)
# 使用参数化查询
query = 'SELECT * FROM employees WHERE department = ?'
df = pd.read_sql(query, conn, params=['IT'])
# 读取整个表
df = pd.read_sql_table('employees', conn)
# 将DataFrame写入SQL数据库
df.to_sql('new_table', conn, if_exists='replace') # 如果表存在则替换
df.to_sql('new_table', conn, if_exists='append') # 如果表存在则追加
# 使用SQLAlchemy连接其他数据库
# MySQL
engine = create_engine('mysql+pymysql://user:password@localhost:3306/database')
# PostgreSQL
engine = create_engine('postgresql://user:password@localhost:5432/database')
# 使用SQLAlchemy引擎读写数据
df = pd.read_sql('SELECT * FROM employees', engine)
df.to_sql('new_table', engine, if_exists='replace')

复制代码

Parquet文件操作

Parquet是一种高效的列式存储格式，适合大数据处理。

import pandas as pd
# 读取Parquet文件
df = pd.read_parquet('data.parquet')
# 写入Parquet文件
df.to_parquet('output.parquet')
# 指定压缩算法
df.to_parquet('output.snappy.parquet', compression='snappy')
df.to_parquet('output.gzip.parquet', compression='gzip')
# 分区写入（大数据处理常用）
# 假设有一个包含日期列的大DataFrame
df['date'] = pd.date_range('2023-01-01', periods=1000)
# 按日期分区
df.to_parquet('partitioned_data', partition_cols=['date'])

复制代码

HDF5文件操作

HDF5是一种适合存储大型科学数据集的格式。

import pandas as pd
import numpy as np
# 创建一个较大的DataFrame用于演示
large_df = pd.DataFrame({
'A': np.random.randn(1000),
'B': np.random.randn(1000),
'C': np.random.randn(1000)
})
# 写入HDF5文件
large_df.to_hdf('large_data.h5', key='df', mode='w')
# 读取HDF5文件
df = pd.read_hdf('large_data.h5', key='df')
# 存储多个DataFrame到同一个HDF5文件
df1 = pd.DataFrame({'A': [1, 2, 3]})
df2 = pd.DataFrame({'B': [4, 5, 6]})
# 使用'store'对象
store = pd.HDFStore('multiple_data.h5')
store['df1'] = df1
store['df2'] = df2
store.close()
# 读取HDF5文件中的多个DataFrame
store = pd.HDFStore('multiple_data.h5')
print(store['df1'])
print(store['df2'])
store.close()

复制代码

高级技巧

在处理文件操作时，掌握一些高级技巧可以大大提高效率和代码质量。

处理大文件

当处理大文件时，内存可能成为瓶颈。pandas提供了几种方法来处理这种情况：

import pandas as pd
# 1. 分块读取CSV文件
chunk_size = 10000 # 每次读取10000行
chunks = pd.read_csv('large_file.csv', chunksize=chunk_size)
for chunk in chunks:
# 处理每个数据块
process_chunk(chunk)
# 2. 指定列读取
# 只读取需要的列，减少内存使用
df = pd.read_csv('large_file.csv', usecols=['col1', 'col2', 'col5'])
# 3. 指定数据类型
# 为每列指定适当的数据类型，减少内存使用
dtypes = {
'id': 'int32',
'name': 'category', # 对于低基数字符串列，使用category类型
'price': 'float32',
'date': 'str'
}
df = pd.read_csv('large_file.csv', dtype=dtypes)
# 4. 使用低内存模式
df = pd.read_csv('large_file.csv', low_memory=True)
# 5. 迭代器模式
# 创建一个迭代器，按需读取数据
reader = pd.read_csv('large_file.csv', iterator=True)
df = reader.get_chunk(1000) # 读取前1000行
df = reader.get_chunk(500) # 再读取500行

复制代码

性能优化

优化文件操作的性能可以显著提高数据处理速度：

import pandas as pd
# 1. 使用更快的引擎
# CSV读取
df = pd.read_csv('data.csv', engine='c') # C引擎（默认）
df = pd.read_csv('data.csv', engine='python') # Python引擎，某些情况下更快
# Excel读取
df = pd.read_excel('data.xlsx', engine='openpyxl') # 适用于.xlsx文件
df = pd.read_excel('data.xls', engine='xlrd') # 适用于.xls文件
# 2. 禁用不必要的功能
# 读取CSV时禁用索引和列名推断
df = pd.read_csv('data.csv', index_col=False, header=None)
# 3. 使用更快的文件格式
# 对于频繁读写的数据，考虑使用更高效的格式如Parquet或HDF5
df.to_parquet('data.parquet') # 写入
df = pd.read_parquet('data.parquet') # 读取
# 4. 并行处理
# 对于多个文件，可以使用多进程并行处理
from multiprocessing import Pool
import os
def process_file(filename):
df = pd.read_csv(filename)
# 处理数据
return processed_df
file_list = [f for f in os.listdir('.') if f.endswith('.csv')]
with Pool(processes=4) as pool: # 使用4个进程
results = pool.map(process_file, file_list)

复制代码

错误处理和异常管理

健壮的代码需要良好的错误处理机制：

import pandas as pd
import os
# 1. 文件存在性检查
filename = 'data.csv'
if os.path.exists(filename):
df = pd.read_csv(filename)
else:
print(f"错误：文件 {filename} 不存在")
# 可以创建一个空DataFrame或采取其他措施
df = pd.DataFrame()
# 2. 使用try-except处理异常
try:
df = pd.read_csv('data.csv', encoding='utf-8')
except UnicodeDecodeError:
try:
# 尝试其他编码
df = pd.read_csv('data.csv', encoding='gbk')
except Exception as e:
print(f"读取文件时出错: {e}")
df = pd.DataFrame()
except FileNotFoundError:
print("文件不存在")
df = pd.DataFrame()
except Exception as e:
print(f"未知错误: {e}")
df = pd.DataFrame()
# 3. 写入文件时的错误处理
try:
df.to_csv('output.csv')
except PermissionError:
print("错误：没有写入权限")
except Exception as e:
print(f"写入文件时出错: {e}")
# 4. 使用上下文管理器处理文件资源
# 对于某些操作，使用with语句确保资源正确释放
with pd.ExcelWriter('output.xlsx') as writer:
df1.to_excel(writer, sheet_name='Sheet1')
df2.to_excel(writer, sheet_name='Sheet2')
# 文件会自动保存并关闭

复制代码

数据验证和清洗

在读取数据后，通常需要进行验证和清洗：

import pandas as pd
import numpy as np
# 读取数据
df = pd.read_csv('data.csv')
# 1. 检查缺失值
print(df.isnull().sum()) # 每列的缺失值数量
# 处理缺失值
df = df.dropna() # 删除包含缺失值的行
df = df.fillna(0) # 用0填充缺失值
df['列名'] = df['列名'].fillna(df['列名'].mean()) # 用均值填充
# 2. 检查数据类型
print(df.dtypes)
# 转换数据类型
df['age'] = df['age'].astype(int)
df['price'] = pd.to_numeric(df['price'], errors='coerce') # 转换为数字，无法转换的设为NaN
# 3. 检查重复值
print(df.duplicated().sum()) # 重复行的数量
# 删除重复值
df = df.drop_duplicates()
# 4. 检查异常值
# 使用描述性统计
print(df.describe())
# 使用IQR方法检测异常值
Q1 = df['列名'].quantile(0.25)
Q3 = df['列名'].quantile(0.75)
IQR = Q3 - Q1
lower_bound = Q1 - 1.5 * IQR
upper_bound = Q3 + 1.5 * IQR
outliers = df[(df['列名'] < lower_bound) | (df['列名'] > upper_bound)]
print(f"检测到 {len(outliers)} 个异常值")
# 5. 字符串清洗
df['text_column'] = df['text_column'].str.strip() # 去除前后空格
df['text_column'] = df['text_column'].str.lower() # 转换为小写
df['text_column'] = df['text_column'].str.replace('[^\w\s]', '') # 去除标点符号

复制代码

实战案例

让我们通过一个综合案例，展示如何将多种文件格式操作结合起来解决实际问题。

案例背景

假设我们是一家零售公司，需要分析销售数据。数据来自多个来源：CSV文件包含每日销售记录，Excel文件包含产品信息和员工信息，JSON文件包含客户反馈。我们需要将这些数据整合起来，进行分析，并生成一份综合报告。

数据准备

首先，让我们创建一些模拟数据：

import pandas as pd
import numpy as np
import json
from datetime import datetime, timedelta
# 1. 创建销售数据 (CSV格式)
np.random.seed(42)
date_range = pd.date_range(start='2023-01-01', end='2023-12-31')
products = ['产品A', '产品B', '产品C', '产品D', '产品E']
stores = ['北京店', '上海店', '广州店', '深圳店']
sales_data = []
for _ in range(10000): # 生成10000条销售记录
sales_data.append({
'日期': np.random.choice(date_range),
'产品ID': np.random.randint(1, 6),
'商店ID': np.random.randint(1, 5),
'销量': np.random.randint(1, 50),
'单价': np.random.uniform(10, 100),
'销售员ID': np.random.randint(1, 21)
})
sales_df = pd.DataFrame(sales_data)
sales_df['总价'] = sales_df['销量'] * sales_df['单价']
sales_df.to_csv('sales_data.csv', index=False, encoding='utf-8')
# 2. 创建产品信息 (Excel格式)
products_data = {
'产品ID': range(1, 6),
'产品名称': products,
'类别': ['电子产品', '服装', '食品', '家具', '化妆品'],
'成本': [15, 30, 5, 50, 25]
}
products_df = pd.DataFrame(products_data)
# 3. 创建商店信息 (Excel格式)
stores_data = {
'商店ID': range(1, 5),
'商店名称': stores,
'城市': ['北京', '上海', '广州', '深圳'],
'区域': ['华北', '华东', '华南', '华南'],
'开业日期': ['2020-01-15', '2019-05-20', '2021-03-10', '2022-07-05']
}
stores_df = pd.DataFrame(stores_data)
# 将产品信息和商店信息写入同一个Excel文件的不同工作表
with pd.ExcelWriter('store_info.xlsx') as writer:
products_df.to_excel(writer, sheet_name='产品信息', index=False)
stores_df.to_excel(writer, sheet_name='商店信息', index=False)
# 4. 创建员工信息 (JSON格式)
employees_data = []
for i in range(1, 21):
employees_data.append({
'员工ID': i,
'姓名': f'员工{i}',
'职位': np.random.choice(['销售员', '销售主管', '店长'], p=[0.7, 0.2, 0.1]),
'入职日期': (datetime.now() - timedelta(days=np.random.randint(30, 2000))).strftime('%Y-%m-%d'),
'商店ID': np.random.randint(1, 5),
'联系方式': {
'电话': f'1{np.random.randint(3000000000, 9999999999)}',
'邮箱': f'employee{i}@example.com'
}
})
with open('employees.json', 'w', encoding='utf-8') as f:
json.dump(employees_data, f, ensure_ascii=False, indent=2)
# 5. 创建客户反馈 (JSON格式)
feedback_data = []
for i in range(500):
feedback_data.append({
'反馈ID': i + 1,
'产品ID': np.random.randint(1, 6),
'客户ID': np.random.randint(1000, 2000),
'评分': np.random.randint(1, 6),
'反馈内容': f'这是关于产品{np.random.randint(1, 6)}的反馈',
'反馈日期': (datetime.now() - timedelta(days=np.random.randint(1, 365))).strftime('%Y-%m-%d')
})
with open('customer_feedback.json', 'w', encoding='utf-8') as f:
json.dump(feedback_data, f, ensure_ascii=False, indent=2)

复制代码

数据整合与分析

现在，我们将读取这些数据并进行整合分析：

import pandas as pd
import json
import numpy as np
from datetime import datetime
import matplotlib.pyplot as plt
# 1. 读取销售数据 (CSV)
print("正在读取销售数据...")
sales_df = pd.read_csv('sales_data.csv', encoding='utf-8')
print(f"销售数据形状: {sales_df.shape}")
print(sales_df.head())
# 2. 读取产品信息和商店信息 (Excel)
print("\n正在读取产品信息和商店信息...")
products_df = pd.read_excel('store_info.xlsx', sheet_name='产品信息')
stores_df = pd.read_excel('store_info.xlsx', sheet_name='商店信息')
print(f"产品数据形状: {products_df.shape}")
print(f"商店数据形状: {stores_df.shape}")
# 3. 读取员工信息 (JSON)
print("\n正在读取员工信息...")
with open('employees.json', 'r', encoding='utf-8') as f:
employees_data = json.load(f)
# 将嵌套的JSON数据扁平化
employees_df = pd.json_normalize(employees_data)
print(f"员工数据形状: {employees_df.shape}")
# 4. 读取客户反馈 (JSON)
print("\n正在读取客户反馈...")
with open('customer_feedback.json', 'r', encoding='utf-8') as f:
feedback_data = json.load(f)
feedback_df = pd.DataFrame(feedback_data)
print(f"反馈数据形状: {feedback_df.shape}")
# 5. 数据整合
print("\n正在整合数据...")
# 合并销售数据和产品信息
sales_products = pd.merge(sales_df, products_df, on='产品ID', how='left')
# 合并商店信息
sales_products_stores = pd.merge(sales_products, stores_df, on='商店ID', how='left')
# 合并员工信息
full_data = pd.merge(sales_products_stores, employees_df, left_on='销售员ID', right_on='员工ID', how='left')
print(f"整合后数据形状: {full_data.shape}")
# 6. 数据清洗
print("\n正在清洗数据...")
# 检查缺失值
print("缺失值统计:")
print(full_data.isnull().sum())
# 处理日期格式
full_data['日期'] = pd.to_datetime(full_data['日期'])
full_data['入职日期'] = pd.to_datetime(full_data['入职日期'])
full_data['开业日期'] = pd.to_datetime(full_data['开业日期'])
# 计算利润
full_data['利润'] = full_data['总价'] - (full_data['销量'] * full_data['成本'])
# 7. 数据分析
print("\n正在进行数据分析...")
# 7.1 销售总额分析
total_sales = full_data['总价'].sum()
total_profit = full_data['利润'].sum()
print(f"销售总额: {total_sales:,.2f}元")
print(f"总利润: {total_profit:,.2f}元")
# 7.2 按产品类别分析
category_sales = full_data.groupby('类别')['总价'].sum().sort_values(ascending=False)
print("\n按产品类别的销售额:")
print(category_sales)
# 7.3 按商店分析
store_sales = full_data.groupby('商店名称')['总价'].sum().sort_values(ascending=False)
print("\n按商店的销售额:")
print(store_sales)
# 7.4 按月份分析
full_data['月份'] = full_data['日期'].dt.to_period('M')
monthly_sales = full_data.groupby('月份')['总价'].sum()
print("\n月度销售额趋势:")
print(monthly_sales.head(12))
# 7.5 员工业绩分析
employee_performance = full_data.groupby(['员工ID', '姓名'])['总价'].sum().sort_values(ascending=False)
print("\n员工销售业绩排行:")
print(employee_performance.head(10))
# 8. 客户反馈分析
print("\n正在分析客户反馈...")
# 合并反馈数据和产品信息
feedback_with_products = pd.merge(feedback_df, products_df, on='产品ID', how='left')
# 计算每个产品的平均评分
product_ratings = feedback_with_products.groupby('产品名称')['评分'].mean().sort_values(ascending=False)
print("\n产品评分排行:")
print(product_ratings)
# 9. 可视化
print("\n正在生成可视化图表...")
# 9.1 产品类别销售额饼图
plt.figure(figsize=(10, 6))
category_sales.plot.pie(autopct='%1.1f%%')
plt.title('按产品类别的销售额分布')
plt.ylabel('')
plt.savefig('category_sales_pie.png')
plt.close()
# 9.2 月度销售额趋势图
plt.figure(figsize=(12, 6))
monthly_sales.plot()
plt.title('月度销售额趋势')
plt.xlabel('月份')
plt.ylabel('销售额')
plt.grid(True)
plt.savefig('monthly_sales_trend.png')
plt.close()
# 9.3 员工业绩条形图
plt.figure(figsize=(12, 6))
employee_performance.head(10).plot.barh()
plt.title('员工销售业绩排行 (前10名)')
plt.xlabel('销售额')
plt.ylabel('员工')
plt.tight_layout()
plt.savefig('employee_performance.png')
plt.close()
# 9.4 产品评分条形图
plt.figure(figsize=(10, 6))
product_ratings.plot.bar()
plt.title('产品评分排行')
plt.xlabel('产品')
plt.ylabel('平均评分')
plt.ylim(0, 5) # 评分范围1-5
plt.tight_layout()
plt.savefig('product_ratings.png')
plt.close()
# 10. 生成综合报告
print("\n正在生成综合报告...")
# 创建一个汇总DataFrame
summary_data = {
'指标': ['销售总额', '总利润', '总订单数', '平均订单金额', '最高评分产品', '最低评分产品', '最佳销售员工'],
'值': [
f"{total_sales:,.2f}元",
f"{total_profit:,.2f}元",
f"{len(full_data):,}",
f"{full_data['总价'].mean():.2f}元",
f"{product_ratings.idxmax()} ({product_ratings.max():.2f}分)",
f"{product_ratings.idxmin()} ({product_ratings.min():.2f}分)",
f"{employee_performance.idxmax()[1]} ({employee_performance.max():,.2f}元)"
]
}
summary_df = pd.DataFrame(summary_data)
# 将汇总数据保存到Excel
with pd.ExcelWriter('sales_analysis_report.xlsx') as writer:
summary_df.to_excel(writer, sheet_name='汇总', index=False)
category_sales.to_excel(writer, sheet_name='按类别销售额')
store_sales.to_excel(writer, sheet_name='按商店销售额')
monthly_sales.to_excel(writer, sheet_name='月度销售额')
employee_performance.to_excel(writer, sheet_name='员工销售业绩')
product_ratings.to_excel(writer, sheet_name='产品评分')
print("\n分析完成！报告已保存到 'sales_analysis_report.xlsx'")
print("可视化图表已保存:")
print("- category_sales_pie.png")
print("- monthly_sales_trend.png")
print("- employee_performance.png")
print("- product_ratings.png")

复制代码

结果输出

执行上述代码后，我们将得到以下输出：

1. 一个名为sales_analysis_report.xlsx的综合报告Excel文件，包含多个工作表：汇总：整体业绩指标按类别销售额：各产品类别的销售情况按商店销售额：各商店的销售情况月度销售额：月度销售趋势员工销售业绩：员工销售业绩排行产品评分：各产品的客户评分情况
2. 汇总：整体业绩指标
3. 按类别销售额：各产品类别的销售情况
4. 按商店销售额：各商店的销售情况
5. 月度销售额：月度销售趋势
6. 员工销售业绩：员工销售业绩排行
7. 产品评分：各产品的客户评分情况
8. 四个可视化图表PNG文件：category_sales_pie.png：产品类别销售额分布饼图monthly_sales_trend.png：月度销售额趋势图employee_performance.png：员工销售业绩排行条形图product_ratings.png：产品评分条形图
9. category_sales_pie.png：产品类别销售额分布饼图
10. monthly_sales_trend.png：月度销售额趋势图
11. employee_performance.png：员工销售业绩排行条形图
12. product_ratings.png：产品评分条形图

一个名为sales_analysis_report.xlsx的综合报告Excel文件，包含多个工作表：

• 汇总：整体业绩指标
• 按类别销售额：各产品类别的销售情况
• 按商店销售额：各商店的销售情况
• 月度销售额：月度销售趋势
• 员工销售业绩：员工销售业绩排行
• 产品评分：各产品的客户评分情况

四个可视化图表PNG文件：

• category_sales_pie.png：产品类别销售额分布饼图
• monthly_sales_trend.png：月度销售额趋势图
• employee_performance.png：员工销售业绩排行条形图
• product_ratings.png：产品评分条形图

这个案例展示了如何使用pandas读取和处理多种格式的数据文件（CSV、Excel、JSON），进行数据整合、清洗、分析，并生成综合报告和可视化图表。通过这种方式，我们可以从多个数据源中提取有价值的信息，为业务决策提供支持。

总结

本文全面介绍了使用pandas进行多种格式文件读取与写入操作的方法，从基础的CSV和Excel文件，到JSON、HTML、SQL、Parquet和HDF5等高级格式。通过详细的代码示例和实战案例，我们展示了如何将这些技术应用到实际数据处理工作中。

关键要点回顾

1. CSV文件操作：使用pd.read_csv()和df.to_csv()进行CSV文件的读写掌握常用参数如sep、encoding、header、index_col等处理大文件时可使用chunksize参数进行分块读取
2. 使用pd.read_csv()和df.to_csv()进行CSV文件的读写
3. 掌握常用参数如sep、encoding、header、index_col等
4. 处理大文件时可使用chunksize参数进行分块读取
5. Excel文件操作：使用pd.read_excel()和df.to_excel()进行Excel文件的读写处理多个工作表、指定单元格位置等高级操作结合ExcelWriter对象进行复杂Excel文件操作
6. 使用pd.read_excel()和df.to_excel()进行Excel文件的读写
7. 处理多个工作表、指定单元格位置等高级操作
8. 结合ExcelWriter对象进行复杂Excel文件操作
9. 其他格式文件操作：JSON：使用pd.read_json()和df.to_json()，处理嵌套JSON时可用pd.json_normalize()HTML：使用pd.read_html()从网页中提取表格数据SQL：使用pd.read_sql()和df.to_sql()与数据库交互Parquet：高效的列式存储格式，适合大数据处理HDF5：适合存储大型科学数据集
10. JSON：使用pd.read_json()和df.to_json()，处理嵌套JSON时可用pd.json_normalize()
11. HTML：使用pd.read_html()从网页中提取表格数据
12. SQL：使用pd.read_sql()和df.to_sql()与数据库交互
13. Parquet：高效的列式存储格式，适合大数据处理
14. HDF5：适合存储大型科学数据集
15. 高级技巧：处理大文件：分块读取、指定列、优化数据类型性能优化：选择合适的引擎、禁用不必要功能、使用高效格式错误处理：文件存在性检查、异常捕获、资源管理数据验证和清洗：处理缺失值、检查数据类型、处理异常值
16. 处理大文件：分块读取、指定列、优化数据类型
17. 性能优化：选择合适的引擎、禁用不必要功能、使用高效格式
18. 错误处理：文件存在性检查、异常捕获、资源管理
19. 数据验证和清洗：处理缺失值、检查数据类型、处理异常值
20. 实战应用：多源数据整合：从不同格式的文件中读取数据并合并数据分析与可视化：生成洞察和图表报告生成：创建综合性的分析报告
21. 多源数据整合：从不同格式的文件中读取数据并合并
22. 数据分析与可视化：生成洞察和图表
23. 报告生成：创建综合性的分析报告

CSV文件操作：

• 使用pd.read_csv()和df.to_csv()进行CSV文件的读写
• 掌握常用参数如sep、encoding、header、index_col等
• 处理大文件时可使用chunksize参数进行分块读取

Excel文件操作：

• 使用pd.read_excel()和df.to_excel()进行Excel文件的读写
• 处理多个工作表、指定单元格位置等高级操作
• 结合ExcelWriter对象进行复杂Excel文件操作

其他格式文件操作：

• JSON：使用pd.read_json()和df.to_json()，处理嵌套JSON时可用pd.json_normalize()
• HTML：使用pd.read_html()从网页中提取表格数据
• SQL：使用pd.read_sql()和df.to_sql()与数据库交互
• Parquet：高效的列式存储格式，适合大数据处理
• HDF5：适合存储大型科学数据集

高级技巧：

• 处理大文件：分块读取、指定列、优化数据类型
• 性能优化：选择合适的引擎、禁用不必要功能、使用高效格式
• 错误处理：文件存在性检查、异常捕获、资源管理
• 数据验证和清洗：处理缺失值、检查数据类型、处理异常值

实战应用：

• 多源数据整合：从不同格式的文件中读取数据并合并
• 数据分析与可视化：生成洞察和图表
• 报告生成：创建综合性的分析报告

最佳实践建议

1. 选择合适的文件格式：对于小型数据集，CSV和Excel是简单易用的选择对于大型数据集，考虑使用Parquet或HDF5等高效格式对于Web应用，JSON是理想的数据交换格式
2. 对于小型数据集，CSV和Excel是简单易用的选择
3. 对于大型数据集，考虑使用Parquet或HDF5等高效格式
4. 对于Web应用，JSON是理想的数据交换格式
5. 优化性能：只读取需要的列和数据为每列指定适当的数据类型对于大型文件，使用分块处理
6. 只读取需要的列和数据
7. 为每列指定适当的数据类型
8. 对于大型文件，使用分块处理
9. 代码健壮性：始终检查文件是否存在使用try-except处理可能的异常确保文件资源正确释放
10. 始终检查文件是否存在
11. 使用try-except处理可能的异常
12. 确保文件资源正确释放
13. 数据质量：读取数据后进行验证和清洗处理缺失值和异常值确保数据类型正确
14. 读取数据后进行验证和清洗
15. 处理缺失值和异常值
16. 确保数据类型正确

选择合适的文件格式：

• 对于小型数据集，CSV和Excel是简单易用的选择
• 对于大型数据集，考虑使用Parquet或HDF5等高效格式
• 对于Web应用，JSON是理想的数据交换格式

优化性能：

• 只读取需要的列和数据
• 为每列指定适当的数据类型
• 对于大型文件，使用分块处理

代码健壮性：

• 始终检查文件是否存在
• 使用try-except处理可能的异常
• 确保文件资源正确释放

数据质量：

• 读取数据后进行验证和清洗
• 处理缺失值和异常值
• 确保数据类型正确

通过掌握pandas的文件操作技能，您可以更加高效地处理各种数据分析任务，从多个来源整合数据，提取有价值的信息，并为业务决策提供支持。希望本文能够帮助您全面掌握pandas的文件操作技能，提升数据处理能力。