简体中文 繁體中文 English Deutsch 한국 사람 بالعربية TÜRKÇE português คนไทย Français Japanese

开启辅助访问 切换到宽版

站内搜索

搜索

活动公告

通知：本站资源由网友上传分享，如有违规等问题请到版务模块进行投诉，将及时处理！
10-23 09:31
>社区 > 科技 > 经验交流 >帖子
本版发帖返回

全面解析Pandas DataFrame数据结构从基础概念到高级技巧助你成为数据处理高手

威震华夏关云长
SunJu_FaceMall

3万

主题

166

科技点

3万

积分

大区版主

碾压王

积分
32106
发表于 2025-8-27 13:00:00 | 显示全部楼层 |阅读模式 [标记阅至此楼]

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

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

x
引言

在数据科学和分析领域，Pandas已经成为Python生态系统中最核心的库之一。作为Pandas库中最重要的数据结构，DataFrame提供了强大而灵活的数据操作能力，使得数据清洗、转换、分析和可视化变得更加高效。本文将全面解析Pandas DataFrame数据结构，从基础概念到高级技巧，帮助你掌握这一强大工具，成为数据处理高手。

Pandas DataFrame基础概念

什么是DataFrame

DataFrame是Pandas库中的一个二维标记数据结构，类似于SQL中的表或Excel中的电子表格。它由一组有序的列组成，每列可以是不同的值类型（数值、字符串、布尔值等）。DataFrame既有行索引也有列索引，可以看作是共享相同索引的Series对象的集合。
  2. import pandas as pd
  3. import numpy as np
  5. # 创建一个简单的DataFrame
  6. data = {
  7.     '姓名': ['张三', '李四', '王五', '赵六'],
  8.     '年龄': [25, 30, 35, 40],
  9.     '城市': ['北京', '上海', '广州', '深圳'],
  10.     '薪资': [8000, 12000, 15000, 20000]
  11. }
  13. df = pd.DataFrame(data)
  14. print(df)
复制代码

输出：
  2. 姓名  年龄  城市     薪资
  3. 0  张三  25  北京   8000
  4. 1  李四  30  上海  12000
  5. 2  王五  35  广州  15000
  6. 3  赵六  40  深圳  20000
复制代码

DataFrame与Series的关系

Series是Pandas中的一维标记数组，可以看作是DataFrame的一列。DataFrame可以看作是多个Series对象的集合，这些Series对象共享同一个索引。
  2. # 从DataFrame中提取一列作为Series
  3. salary_series = df['薪资']
  4. print(type(salary_series))
  5. print(salary_series)
复制代码

输出：
  2. <class 'pandas.core.series.Series'>
  3. 0     8000
  4. 1    12000
  5. 2    15000
  6. 3    20000
  7. Name: 薪资, dtype: int64
复制代码

DataFrame的基本属性

DataFrame有许多有用的属性，可以帮助我们了解数据的基本情况：
  2. # 查看DataFrame的形状（行数，列数）
  3. print("形状:", df.shape)
  5. # 查看列名
  6. print("列名:", df.columns.tolist())
  8. # 查看索引
  9. print("索引:", df.index.tolist())
  11. # 查看数据类型
  12. print("数据类型:\n", df.dtypes)
  14. # 查看数据的统计摘要
  15. print("统计摘要:\n", df.describe())
  17. # 查看前几行数据（默认5行）
  18. print("前两行数据:\n", df.head(2))
  20. # 查看后几行数据（默认5行）
  21. print("后两行数据:\n", df.tail(2))
  23. # 获取数据的转置
  24. print("转置:\n", df.T)
复制代码

创建DataFrame的不同方法

从字典创建

最常用的创建DataFrame的方式是从字典创建，字典的键将成为列名，值将成为列数据。
  2. # 从字典创建DataFrame
  3. data = {
  4.     '产品': ['A', 'B', 'C', 'D'],
  5.     '销量': [100, 150, 200, 120],
  6.     '价格': [10.5, 20.3, 15.8, 18.9]
  7. }
  9. df_from_dict = pd.DataFrame(data)
  10. print(df_from_dict)
复制代码

从列表创建

可以从嵌套列表创建DataFrame，需要单独指定列名。
  2. # 从列表创建DataFrame
  3. data = [
  4.     ['A', 100, 10.5],
  5.     ['B', 150, 20.3],
  6.     ['C', 200, 15.8],
  7.     ['D', 120, 18.9]
  8. ]
  10. columns = ['产品', '销量', '价格']
  11. df_from_list = pd.DataFrame(data, columns=columns)
  12. print(df_from_list)
复制代码

从NumPy数组创建

可以从NumPy数组创建DataFrame，这对于科学计算特别有用。
  2. # 从NumPy数组创建DataFrame
  3. array = np.random.rand(5, 4)  # 创建一个5行4列的随机数数组
  4. columns = ['A', 'B', 'C', 'D']
  5. df_from_array = pd.DataFrame(array, columns=columns)
  6. print(df_from_array)
复制代码

从文件读取

Pandas支持从多种文件格式读取数据，包括CSV、Excel、JSON、SQL等。
  2. # 从CSV文件读取
  3. # df_csv = pd.read_csv('data.csv')
  5. # 从Excel文件读取
  6. # df_excel = pd.read_excel('data.xlsx', sheet_name='Sheet1')
  8. # 从JSON文件读取
  9. # df_json = pd.read_json('data.json')
  11. # 从SQL查询读取
  12. # import sqlite3
  13. # conn = sqlite3.connect('database.db')
  14. # df_sql = pd.read_sql('SELECT * FROM table_name', conn)
  15. # conn.close()
复制代码

DataFrame基本操作

查看数据
  2. # 创建一个示例DataFrame
  3. data = {
  4.     '姓名': ['张三', '李四', '王五', '赵六', '钱七'],
  5.     '年龄': [25, 30, 35, 40, 45],
  6.     '城市': ['北京', '上海', '广州', '深圳', '杭州'],
  7.     '薪资': [8000, 12000, 15000, 20000, 18000]
  8. }
  9. df = pd.DataFrame(data)
  11. # 查看前n行
  12. print(df.head(3))
  14. # 查看后n行
  15. print(df.tail(2))
  17. # 查看随机n行
  18. print(df.sample(2))
  20. # 查看基本信息
  21. print(df.info())
  23. # 查看描述性统计
  24. print(df.describe())
复制代码

选择数据
  2. # 选择单列 - 返回Series
  3. name_series = df['姓名']
  4. print(name_series)
  5. print(type(name_series))
  7. # 选择多列 - 返回DataFrame
  8. subset = df[['姓名', '薪资']]
  9. print(subset)
  10. print(type(subset))
复制代码
  2. # 使用loc基于标签选择行
  3. print(df.loc[0])  # 选择第一行
  4. print(df.loc[0:2])  # 选择前三行
  6. # 使用iloc基于位置选择行
  7. print(df.iloc[0])  # 选择第一行
  8. print(df.iloc[0:3])  # 选择前三行
  10. # 条件选择
  11. high_salary = df[df['薪资'] > 15000]
  12. print(high_salary)
  14. # 多条件选择
  15. beijing_or_shanghai = df[(df['城市'] == '北京') | (df['城市'] == '上海')]
  16. print(beijing_or_shanghai)
  18. # 使用isin方法
  19. selected_cities = df[df['城市'].isin(['北京', '上海'])]
  20. print(selected_cities)
复制代码
  2. # 使用at选择单个单元格（基于标签）
  3. print(df.at[1, '姓名'])  # 输出: 李四
  5. # 使用iat选择单个单元格（基于位置）
  6. print(df.iat[1, 0])  # 输出: 李四
  8. # 使用loc选择单元格区域
  9. print(df.loc[1:3, ['姓名', '薪资']])
  11. # 使用iloc选择单元格区域
  12. print(df.iloc[1:4, [0, 3]])
复制代码

数据过滤
  2. # 单条件过滤
  3. age_above_30 = df[df['年龄'] > 30]
  4. print(age_above_30)
  6. # 多条件过滤 - 使用&（与）、|（或）、~（非）
  7. age_30_to_40 = df[(df['年龄'] >= 30) & (df['年龄'] <= 40)]
  8. print(age_30_to_40)
  10. # 使用query方法
  11. query_result = df.query('年龄 > 30 and 薪资 < 20000')
  12. print(query_result)
  14. # 使用字符串方法过滤
  15. name_starts_with_z = df[df['姓名'].str.startswith('张')]
  16. print(name_starts_with_z)
复制代码

数据排序
  2. # 按单列排序
  3. sorted_by_age = df.sort_values('年龄')
  4. print(sorted_by_age)
  6. # 按多列排序
  7. sorted_by_age_salary = df.sort_values(['年龄', '薪资'], ascending=[True, False])
  8. print(sorted_by_age_salary)
  10. # 按索引排序
  11. sorted_by_index = df.sort_index()
  12. print(sorted_by_index)
  14. # 设置新列并按其排序
  15. df['薪资等级'] = ['低', '中', '中', '高', '高']
  16. sorted_by_rank = df.sort_values('薪资等级')
  17. print(sorted_by_rank)
复制代码

数据清洗与预处理

处理缺失值
  2. # 创建带有缺失值的DataFrame
  3. data_with_nan = {
  4.     'A': [1, 2, np.nan, 4, 5],
  5.     'B': [np.nan, 2, 3, np.nan, 5],
  6.     'C': [1, 2, 3, 4, 5],
  7.     'D': ['a', 'b', np.nan, 'd', 'e']
  8. }
  9. df_nan = pd.DataFrame(data_with_nan)
  10. print(df_nan)
  12. # 检测缺失值
  13. print(df_nan.isna())
  15. # 统计每列的缺失值数量
  16. print(df_nan.isna().sum())
  18. # 删除含有缺失值的行
  19. df_dropped_rows = df_nan.dropna()
  20. print(df_dropped_rows)
  22. # 删除含有缺失值的列
  23. df_dropped_cols = df_nan.dropna(axis=1)
  24. print(df_dropped_cols)
  26. # 填充缺失值
  27. df_filled = df_nan.fillna(0)
  28. print(df_filled)
  30. # 使用列的平均值填充数值列
  31. df_nan['A'] = df_nan['A'].fillna(df_nan['A'].mean())
  32. print(df_nan)
  34. # 使用前一个值填充缺失值
  35. df_ffill = df_nan.fillna(method='ffill')
  36. print(df_ffill)
  38. # 使用后一个值填充缺失值
  39. df_bfill = df_nan.fillna(method='bfill')
  40. print(df_bfill)
  42. # 使用插值法填充缺失值
  43. df_interpolated = df_nan.copy()
  44. df_interpolated['A'] = df_interpolated['A'].interpolate()
  45. print(df_interpolated)
复制代码

数据类型转换
  2. # 创建示例DataFrame
  3. data_types = {
  4.     'ID': ['001', '002', '003', '004'],
  5.     '价格': ['10.5', '20.3', '15.8', '18.9'],
  6.     '数量': ['100', '150', '200', '120'],
  7.     '日期': ['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04']
  8. }
  9. df_types = pd.DataFrame(data_types)
  10. print(df_types.dtypes)
  12. # 转换数据类型
  13. df_types['价格'] = df_types['价格'].astype(float)
  14. df_types['数量'] = df_types['数量'].astype(int)
  15. df_types['日期'] = pd.to_datetime(df_types['日期'])
  16. print(df_types.dtypes)
  18. # 使用pd.to_numeric进行更安全的转换
  19. df_types['ID'] = pd.to_numeric(df_types['ID'], errors='ignore')  # 如果转换失败则保持原样
  20. print(df_types.dtypes)
  22. # 分类类型转换 - 适用于重复的字符串值
  23. df_types['城市'] = ['北京', '上海', '北京', '上海']
  24. df_types['城市'] = df_types['城市'].astype('category')
  25. print(df_types['城市'].dtype)
复制代码

重复值处理
  2. # 创建带有重复值的DataFrame
  3. data_duplicates = {
  4.     'ID': [1, 2, 3, 4, 1, 2],
  5.     '姓名': ['张三', '李四', '王五', '赵六', '张三', '李四'],
  6.     '年龄': [25, 30, 35, 40, 25, 30]
  7. }
  8. df_duplicates = pd.DataFrame(data_duplicates)
  9. print(df_duplicates)
  11. # 检测重复行
  12. print(df_duplicates.duplicated())
  14. # 统计重复行数量
  15. print(df_duplicates.duplicated().sum())
  17. # 删除重复行
  18. df_no_duplicates = df_duplicates.drop_duplicates()
  19. print(df_no_duplicates)
  21. # 基于特定列删除重复行
  22. df_unique_id = df_duplicates.drop_duplicates(subset=['ID'])
  23. print(df_unique_id)
  25. # 保留最后一个出现的重复行
  26. df_keep_last = df_duplicates.drop_duplicates(keep='last')
  27. print(df_keep_last)
复制代码

异常值检测与处理
  2. # 创建包含异常值的DataFrame
  3. np.random.seed(42)
  4. data_outliers = {
  5.     'A': np.concatenate([np.random.normal(0, 1, 50), [10, -10]]),
  6.     'B': np.concatenate([np.random.normal(5, 2, 50), [20, -15]])
  7. }
  8. df_outliers = pd.DataFrame(data_outliers)
  10. # 使用箱线图检测异常值
  11. import matplotlib.pyplot as plt
  12. plt.figure(figsize=(10, 5))
  13. df_outliers.boxplot()
  14. plt.title('箱线图检测异常值')
  15. plt.show()
  17. # 使用Z-score检测异常值
  18. from scipy import stats
  19. z_scores = stats.zscore(df_outliers)
  20. abs_z_scores = np.abs(z_scores)
  21. outliers = (abs_z_scores > 3).any(axis=1)
  22. print("异常值索引:", np.where(outliers)[0])
  24. # 使用IQR方法检测异常值
  25. Q1 = df_outliers.quantile(0.25)
  26. Q3 = df_outliers.quantile(0.75)
  27. IQR = Q3 - Q1
  28. outliers_iqr = ((df_outliers < (Q1 - 1.5 * IQR)) | (df_outliers > (Q3 + 1.5 * IQR))).any(axis=1)
  29. print("IQR方法检测到的异常值索引:", np.where(outliers_iqr)[0])
  31. # 处理异常值 - 删除
  32. df_no_outliers = df_outliers[~outliers]
  33. print("删除异常值后的形状:", df_no_outliers.shape)
  35. # 处理异常值 - 替换为中位数
  36. df_replace_median = df_outliers.copy()
  37. for column in df_replace_median.columns:
  38.     median = df_replace_median[column].median()
  39.     df_replace_median.loc[outliers, column] = median
  40. print(df_replace_median.loc[outliers])
复制代码

数据转换与处理

添加/删除列
  2. # 创建示例DataFrame
  3. data = {
  4.     '姓名': ['张三', '李四', '王五', '赵六'],
  5.     '年龄': [25, 30, 35, 40],
  6.     '城市': ['北京', '上海', '广州', '深圳']
  7. }
  8. df = pd.DataFrame(data)
  10. # 添加新列
  11. df['薪资'] = [8000, 12000, 15000, 20000]
  12. print(df)
  14. # 基于现有列创建新列
  15. df['年薪'] = df['薪资'] * 12
  16. print(df)
  18. # 使用assign方法添加列（不会修改原DataFrame）
  19. df_new = df.assign(月薪等级=['低', '中', '中', '高'])
  20. print(df_new)
  21. print("原DataFrame未改变:", df.columns.tolist())
  23. # 删除列
  24. df_dropped = df.drop('年薪', axis=1)
  25. print(df_dropped)
  27. # 使用del删除列
  28. df_copy = df.copy()
  29. del df_copy['年薪']
  30. print(df_copy)
  32. # 使用pop删除列并返回
  33. df_copy = df.copy()
  34. salary = df_copy.pop('薪资')
  35. print(df_copy)
  36. print("被删除的列:\n", salary)
复制代码

应用函数
  2. # 创建示例DataFrame
  3. data = {
  4.     '姓名': ['张三', '李四', '王五', '赵六'],
  5.     '年龄': [25, 30, 35, 40],
  6.     '薪资': [8000, 12000, 15000, 20000]
  7. }
  8. df = pd.DataFrame(data)
  10. # 对列应用函数
  11. df['年龄平方'] = df['年龄'].apply(lambda x: x ** 2)
  12. print(df)
  14. # 对多列应用函数
  15. df['薪资等级'] = df.apply(lambda row: '高' if row['薪资'] > 15000 else ('中' if row['薪资'] > 10000 else '低'), axis=1)
  16. print(df)
  18. # 使用applymap对每个元素应用函数
  19. df_str = df.copy()
  20. df_str[['姓名', '薪资等级']] = df_str[['姓名', '薪资等级']].applymap(lambda x: str(x) + '!')
  21. print(df_str)
  23. # 使用map函数对Series进行转换
  24. df['城市代码'] = df['姓名'].map({'张三': 1001, '李四': 1002, '王五': 1003, '赵六': 1004})
  25. print(df)
  27. # 使用transform函数
  28. df['年龄差异'] = df['年龄'].transform(lambda x: x - x.mean())
  29. print(df)
  31. # 使用agg函数应用多个聚合函数
  32. print(df[['年龄', '薪资']].agg(['mean', 'max', 'min']))
复制代码

分组操作
  2. # 创建示例DataFrame
  3. data = {
  4.     '部门': ['技术', '市场', '技术', '财务', '市场', '技术', '财务'],
  5.     '姓名': ['张三', '李四', '王五', '赵六', '钱七', '孙八', '周九'],
  6.     '年龄': [25, 30, 35, 40, 28, 32, 45],
  7.     '薪资': [8000, 12000, 15000, 20000, 10000, 14000, 22000]
  8. }
  9. df = pd.DataFrame(data)
  11. # 按部门分组
  12. grouped = df.groupby('部门')
  14. # 计算每组的平均薪资
  15. avg_salary = grouped['薪资'].mean()
  16. print(avg_salary)
  18. # 计算每组的多个统计量
  19. stats = grouped['薪资'].agg(['mean', 'max', 'min', 'count'])
  20. print(stats)
  22. # 对多列应用不同的聚合函数
  23. multi_agg = grouped.agg({
  24.     '年龄': ['mean', 'max'],
  25.     '薪资': ['mean', 'sum', 'count']
  26. })
  27. print(multi_agg)
  29. # 自定义聚合函数
  30. def salary_range(x):
  31.     return x.max() - x.min()
  33. range_result = grouped['薪资'].agg(salary_range)
  34. print(range_result)
  36. # 遍历分组
  37. for name, group in grouped:
  38.     print(f"部门: {name}")
  39.     print(group)
  40.     print()
  42. # 使用transform进行分组转换
  43. df['部门平均薪资'] = grouped['薪资'].transform('mean')
  44. print(df)
  46. # 使用filter过滤分组
  47. tech_dept = grouped.filter(lambda x: x['部门'].iloc[0] == '技术')
  48. print(tech_dept)
复制代码

数据透视表
  2. # 创建示例DataFrame
  3. data = {
  4.     '日期': pd.date_range('2023-01-01', periods=12),
  5.     '产品': ['A', 'B', 'A', 'B', 'A', 'B', 'A', 'B', 'A', 'B', 'A', 'B'],
  6.     '地区': ['北京', '北京', '上海', '上海', '广州', '广州', '北京', '北京', '上海', '上海', '广州', '广州'],
  7.     '销售额': [100, 150, 200, 120, 180, 160, 110, 140, 210, 130, 190, 170],
  8.     '成本': [60, 90, 120, 72, 108, 96, 66, 84, 126, 78, 114, 102]
  9. }
  10. df = pd.DataFrame(data)
  12. # 创建数据透视表
  13. pivot = pd.pivot_table(df,
  14.                       values='销售额',
  15.                       index='产品',
  16.                       columns='地区',
  17.                       aggfunc='sum')
  18. print(pivot)
  20. # 多值数据透视表
  21. pivot_multi = pd.pivot_table(df,
  22.                             values=['销售额', '成本'],
  23.                             index='产品',
  24.                             columns='地区',
  25.                             aggfunc='sum')
  26. print(pivot_multi)
  28. # 添加总计行和列
  29. pivot_with_totals = pd.pivot_table(df,
  30.                                   values='销售额',
  31.                                   index='产品',
  32.                                   columns='地区',
  33.                                   aggfunc='sum',
  34.                                   margins=True,
  35.                                   margins_name='总计')
  36. print(pivot_with_totals)
  38. # 多级索引数据透视表
  39. pivot_multi_index = pd.pivot_table(df,
  40.                                   values='销售额',
  41.                                   index=['产品', '地区'],
  42.                                   aggfunc='sum')
  43. print(pivot_multi_index)
  45. # 使用多个聚合函数
  46. pivot_multi_agg = pd.pivot_table(df,
  47.                                 values='销售额',
  48.                                 index='产品',
  49.                                 columns='地区',
  50.                                 aggfunc=['sum', 'mean', 'count'])
  51. print(pivot_multi_agg)
复制代码

高级技巧

多级索引
  2. # 创建多级索引DataFrame
  3. arrays = [
  4.     ['A', 'A', 'B', 'B', 'C', 'C'],
  5.     ['X', 'Y', 'X', 'Y', 'X', 'Y']
  6. ]
  7. tuples = list(zip(*arrays))
  8. index = pd.MultiIndex.from_tuples(tuples, names=['一级', '二级'])
  9. df_multi = pd.DataFrame(np.random.randn(6, 2), index=index, columns=['值1', '值2'])
  10. print(df_multi)
  12. # 选择多级索引数据
  13. print(df_multi.loc['A'])
  14. print(df_multi.loc[('A', 'X')])
  15. print(df_multi.loc[:, '值1'])
  17. # 使用xs方法
  18. print(df_multi.xs('A', level='一级'))
  19. print(df_multi.xs('X', level='二级'))
  21. # 设置多级索引
  22. data = {
  23.     '部门': ['技术', '技术', '市场', '市场', '财务', '财务'],
  24.     '团队': ['前端', '后端', '推广', '销售', '会计', '审计'],
  25.     '员工': ['张三', '李四', '王五', '赵六', '钱七', '孙八'],
  26.     '薪资': [8000, 12000, 10000, 15000, 9000, 11000]
  27. }
  28. df = pd.DataFrame(data)
  29. df_multi = df.set_index(['部门', '团队'])
  30. print(df_multi)
  32. # 交换索引级别
  33. df_swapped = df_multi.swaplevel()
  34. print(df_swapped)
  36. # 排序索引
  37. df_sorted = df_multi.sort_index(level=0)
  38. print(df_sorted)
  40. # 重置索引
  41. df_reset = df_multi.reset_index()
  42. print(df_reset)
复制代码

时间序列处理
  2. # 创建时间序列数据
  3. dates = pd.date_range('20230101', periods=10)
  4. ts = pd.Series(np.random.randn(10), index=dates)
  5. print(ts)
  7. # 选择特定时间范围的数据
  8. print(ts['2023-01-03':'2023-01-07'])
  9. print(ts['2023-01'])  # 选择整个月
  11. # 创建带有时间索引的DataFrame
  12. data = {
  13.     '日期': pd.date_range('20230101', periods=30),
  14.     '销售额': np.random.randint(100, 200, size=30),
  15.     '成本': np.random.randint(50, 100, size=30)
  16. }
  17. df_ts = pd.DataFrame(data)
  18. df_ts.set_index('日期', inplace=True)
  19. print(df_ts.head())
  21. # 重采样
  22. # 按周重采样，计算每周的平均值
  23. weekly_avg = df_ts.resample('W').mean()
  24. print(weekly_avg)
  26. # 按月重采样，计算每月的总和
  27. monthly_sum = df_ts.resample('M').sum()
  28. print(monthly_sum)
  30. # 移动窗口
  31. # 计算7天移动平均
  32. df_ts['销售额_7天移动平均'] = df_ts['销售额'].rolling(window=7).mean()
  33. print(df_ts[['销售额', '销售额_7天移动平均']].head(10))
  35. # 计算扩展窗口统计
  36. df_ts['销售额累计最大'] = df_ts['销售额'].expanding().max()
  37. print(df_ts[['销售额', '销售额累计最大']].head())
  39. # 时间偏移
  40. df_ts['前一天销售额'] = df_ts['销售额'].shift(1)
  41. print(df_ts[['销售额', '前一天销售额']].head())
  43. # 计算变化率
  44. df_ts['销售额日变化率'] = df_ts['销售额'].pct_change()
  45. print(df_ts[['销售额', '销售额日变化率']].head())
  47. # 处理时区
  48. # 创建带时区的时间序列
  49. ts_utc = ts.tz_localize('UTC')
  50. print(ts_utc)
  52. # 转换时区
  53. ts_est = ts_utc.tz_convert('US/Eastern')
  54. print(ts_est)
复制代码

合并与连接
  2. # 创建示例DataFrame
  3. df1 = pd.DataFrame({
  4.     'ID': [1, 2, 3, 4],
  5.     '姓名': ['张三', '李四', '王五', '赵六'],
  6.     '年龄': [25, 30, 35, 40]
  7. })
  9. df2 = pd.DataFrame({
  10.     'ID': [1, 2, 3, 5],
  11.     '薪资': [8000, 12000, 15000, 18000],
  12.     '部门': ['技术', '市场', '财务', '人事']
  13. })
  15. # 内连接
  16. inner_merge = pd.merge(df1, df2, on='ID', how='inner')
  17. print("内连接:")
  18. print(inner_merge)
  20. # 左连接
  21. left_merge = pd.merge(df1, df2, on='ID', how='left')
  22. print("\n左连接:")
  23. print(left_merge)
  25. # 右连接
  26. right_merge = pd.merge(df1, df2, on='ID', how='right')
  27. print("\n右连接:")
  28. print(right_merge)
  30. # 外连接
  31. outer_merge = pd.merge(df1, df2, on='ID', how='outer')
  32. print("\n外连接:")
  33. print(outer_merge)
  35. # 基于多列连接
  36. df3 = pd.DataFrame({
  37.     '姓名': ['张三', '李四', '王五', '赵六'],
  38.     '年龄': [25, 30, 35, 40],
  39.     '城市': ['北京', '上海', '广州', '深圳']
  40. })
  42. df4 = pd.DataFrame({
  43.     '姓名': ['张三', '李四', '王五', '钱七'],
  44.     '年龄': [25, 30, 35, 45],
  45.     '薪资': [8000, 12000, 15000, 18000]
  46. })
  48. multi_merge = pd.merge(df3, df4, on=['姓名', '年龄'], how='inner')
  49. print("\n基于多列连接:")
  50. print(multi_merge)
  52. # 纵向拼接
  53. df5 = pd.DataFrame({
  54.     'ID': [5, 6, 7],
  55.     '姓名': ['钱七', '孙八', '周九'],
  56.     '年龄': [45, 50, 55]
  57. })
  59. concat_vertical = pd.concat([df1, df5], ignore_index=True)
  60. print("\n纵向拼接:")
  61. print(concat_vertical)
  63. # 横向拼接
  64. df6 = pd.DataFrame({
  65.     '城市': ['北京', '上海', '广州', '深圳'],
  66.     '学历': ['本科', '硕士', '本科', '博士']
  67. })
  69. concat_horizontal = pd.concat([df1, df6], axis=1)
  70. print("\n横向拼接:")
  71. print(concat_horizontal)
  73. # 使用join方法
  74. df7 = df1.set_index('ID')
  75. df8 = df2.set_index('ID')
  77. join_result = df7.join(df8, how='inner')
  78. print("\n使用join方法:")
  79. print(join_result)
复制代码

性能优化
  2. # 创建大型DataFrame
  3. large_df = pd.DataFrame({
  4.     'A': np.random.rand(100000),
  5.     'B': np.random.rand(100000),
  6.     'C': np.random.randint(0, 100, size=100000),
  7.     'D': np.random.choice(['X', 'Y', 'Z'], size=100000)
  8. })
  10. # 优化内存使用
  11. # 查看当前内存使用
  12. print("原始内存使用:")
  13. print(large_df.memory_usage(deep=True))
  15. # 降级数值类型
  16. large_df['A'] = pd.to_numeric(large_df['A'], downcast='float')
  17. large_df['B'] = pd.to_numeric(large_df['B'], downcast='float')
  18. large_df['C'] = pd.to_numeric(large_df['C'], downcast='integer')
  20. # 将字符串列转换为分类类型
  21. large_df['D'] = large_df['D'].astype('category')
  23. print("\n优化后内存使用:")
  24. print(large_df.memory_usage(deep=True))
  26. # 使用eval进行高效计算
  27. # 传统方法
  28. %timeit large_df['E'] = large_df['A'] + large_df['B'] * large_df['C']
  30. # 使用eval方法
  31. %timeit large_df.eval('F = A + B * C', inplace=True)
  33. # 使用query进行高效过滤
  34. # 传统方法
  35. %timeit filtered = large_df[(large_df['A'] > 0.5) & (large_df['C'] > 50)]
  37. # 使用query方法
  38. %timeit filtered_query = large_df.query('A > 0.5 and C > 50')
  40. # 使用itertuples进行高效行迭代
  41. # 传统iterrows方法
  42. %timeit for idx, row in large_df.head(1000).iterrows(): pass
  44. # 使用itertuples方法
  45. %timeit for row in large_df.head(1000).itertuples(): pass
  47. # 使用apply与向量化操作
  48. # 创建一个函数
  49. def custom_function(x):
  50.     return x * 2 + 1
  52. # 使用apply
  53. %timeit result_apply = large_df['A'].apply(custom_function)
  55. # 使用向量化操作
  56. %timeit result_vectorized = custom_function(large_df['A'])
  58. # 使用cython或numba加速
  59. # 安装numba: pip install numba
  60. from numba import jit
  62. @jit(nopython=True)
  63. def numba_function(x):
  64.     result = np.empty_like(x)
  65.     for i in range(len(x)):
  66.         result[i] = x[i] * 2 + 1
  67.     return result
  69. %timeit result_numba = numba_function(large_df['A'].values)
复制代码

实战案例

数据分析实例

让我们通过一个实际的数据分析案例来综合运用前面学到的知识。假设我们有一份销售数据，需要进行清洗、分析和可视化。
  2. # 创建模拟销售数据
  3. np.random.seed(42)
  4. dates = pd.date_range('2022-01-01', '2022-12-31')
  5. products = ['A', 'B', 'C', 'D', 'E']
  6. regions = ['北部', '南部', '东部', '西部']
  8. # 生成随机数据
  9. n_records = 1000
  10. sales_data = {
  11.     '日期': np.random.choice(dates, n_records),
  12.     '产品': np.random.choice(products, n_records),
  13.     '地区': np.random.choice(regions, n_records),
  14.     '销售额': np.random.randint(100, 1000, n_records),
  15.     '成本': np.random.randint(50, 500, n_records),
  16.     '销售员': np.random.choice(['张三', '李四', '王五', '赵六', '钱七'], n_records)
  17. }
  19. df_sales = pd.DataFrame(sales_data)
  20. print("原始数据预览:")
  21. print(df_sales.head())
  23. # 数据清洗
  24. # 1. 检查缺失值
  25. print("\n缺失值统计:")
  26. print(df_sales.isna().sum())
  28. # 2. 添加利润列
  29. df_sales['利润'] = df_sales['销售额'] - df_sales['成本']
  31. # 3. 添加利润率列
  32. df_sales['利润率'] = df_sales['利润'] / df_sales['销售额']
  34. # 4. 添加月份列
  35. df_sales['月份'] = df_sales['日期'].dt.month
  37. # 5. 添加季度列
  38. df_sales['季度'] = df_sales['日期'].dt.quarter
  40. # 数据分析
  41. # 1. 按产品分析销售情况
  42. product_stats = df_sales.groupby('产品').agg({
  43.     '销售额': ['sum', 'mean', 'count'],
  44.     '利润': ['sum', 'mean'],
  45.     '利润率': 'mean'
  46. })
  47. print("\n产品销售统计:")
  48. print(product_stats)
  50. # 2. 按地区分析销售情况
  51. region_stats = df_sales.groupby('地区').agg({
  52.     '销售额': 'sum',
  53.     '利润': 'sum'
  54. }).sort_values('销售额', ascending=False)
  55. print("\n地区销售统计:")
  56. print(region_stats)
  58. # 3. 按月份分析销售趋势
  59. monthly_sales = df_sales.groupby('月份')['销售额'].sum()
  60. print("\n月度销售趋势:")
  61. print(monthly_sales)
  63. # 4. 销售员业绩分析
  64. salesperson_stats = df_sales.groupby('销售员').agg({
  65.     '销售额': 'sum',
  66.     '利润': 'sum',
  67.     '利润率': 'mean'
  68. }).sort_values('销售额', ascending=False)
  69. print("\n销售员业绩统计:")
  70. print(salesperson_stats)
  72. # 5. 产品-地区交叉分析
  73. product_region_pivot = pd.pivot_table(
  74.     df_sales,
  75.     values='销售额',
  76.     index='产品',
  77.     columns='地区',
  78.     aggfunc='sum',
  79.     margins=True
  80. )
  81. print("\n产品-地区交叉分析:")
  82. print(product_region_pivot)
  84. # 6. 找出最佳销售组合
  85. best_combinations = df_sales.groupby(['产品', '地区'])['销售额'].sum().sort_values(ascending=False).head(10)
  86. print("\n最佳销售组合:")
  87. print(best_combinations)
复制代码

数据可视化结合

让我们使用Matplotlib和Seaborn库来可视化我们的分析结果：
  2. import matplotlib.pyplot as plt
  3. import seaborn as sns
  4. plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
  5. plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
  7. # 1. 产品销售额对比
  8. plt.figure(figsize=(10, 6))
  9. product_sales = df_sales.groupby('产品')['销售额'].sum().sort_values(ascending=False)
  10. sns.barplot(x=product_sales.index, y=product_sales.values)
  11. plt.title('各产品销售额对比')
  12. plt.xlabel('产品')
  13. plt.ylabel('销售额')
  14. plt.show()
  16. # 2. 地区销售额占比
  17. plt.figure(figsize=(10, 6))
  18. region_sales = df_sales.groupby('地区')['销售额'].sum()
  19. plt.pie(region_sales, labels=region_sales.index, autopct='%1.1f%%', startangle=90)
  20. plt.title('各地区销售额占比')
  21. plt.axis('equal')  # 使饼图呈正圆形
  22. plt.show()
  24. # 3. 月度销售趋势
  25. plt.figure(figsize=(12, 6))
  26. monthly_sales = df_sales.groupby('月份')['销售额'].sum()
  27. sns.lineplot(x=monthly_sales.index, y=monthly_sales.values, marker='o')
  28. plt.title('月度销售趋势')
  29. plt.xlabel('月份')
  30. plt.ylabel('销售额')
  31. plt.xticks(range(1, 13))
  32. plt.grid(True)
  33. plt.show()
  35. # 4. 销售员业绩对比
  36. plt.figure(figsize=(10, 6))
  37. salesperson_performance = df_sales.groupby('销售员')['销售额'].sum().sort_values(ascending=False)
  38. sns.barplot(x=salesperson_performance.index, y=salesperson_performance.values)
  39. plt.title('销售员业绩对比')
  40. plt.xlabel('销售员')
  41. plt.ylabel('销售额')
  42. plt.show()
  44. # 5. 产品-地区热力图
  45. plt.figure(figsize=(10, 8))
  46. product_region_heatmap = pd.pivot_table(
  47.     df_sales,
  48.     values='销售额',
  49.     index='产品',
  50.     columns='地区',
  51.     aggfunc='sum'
  52. )
  53. sns.heatmap(product_region_heatmap, annot=True, fmt='.0f', cmap='YlGnBu')
  54. plt.title('产品-地区销售额热力图')
  55. plt.xlabel('地区')
  56. plt.ylabel('产品')
  57. plt.show()
  59. # 6. 销售额与利润散点图
  60. plt.figure(figsize=(10, 6))
  61. sns.scatterplot(x='销售额', y='利润', hue='产品', data=df_sales, alpha=0.7)
  62. plt.title('销售额与利润关系')
  63. plt.xlabel('销售额')
  64. plt.ylabel('利润')
  65. plt.show()
  67. # 7. 利润率分布
  68. plt.figure(figsize=(10, 6))
  69. sns.histplot(df_sales['利润率'], bins=20, kde=True)
  70. plt.title('利润率分布')
  71. plt.xlabel('利润率')
  72. plt.ylabel('频次')
  73. plt.show()
  75. # 8. 季度销售对比
  76. plt.figure(figsize=(10, 6))
  77. quarterly_sales = df_sales.groupby('季度')['销售额'].sum()
  78. sns.barplot(x=quarterly_sales.index, y=quarterly_sales.values)
  79. plt.title('季度销售对比')
  80. plt.xlabel('季度')
  81. plt.ylabel('销售额')
  82. plt.show()
复制代码

总结与最佳实践

通过本文的全面解析，我们深入了解了Pandas DataFrame数据结构的基础概念和高级技巧。下面总结一些关键点和最佳实践：

关键点总结

1. DataFrame基础：DataFrame是Pandas中最重要的数据结构，类似于Excel表格或SQL表，由行和列组成。
2. 数据创建：可以通过字典、列表、NumPy数组或从文件读取等多种方式创建DataFrame。
3. 数据选择：使用loc（基于标签）、iloc（基于位置）和条件过滤等方法选择数据。
4. 数据清洗：处理缺失值、重复值、异常值和数据类型转换是数据预处理的重要步骤。
5. 数据转换：添加/删除列、应用函数、分组操作和数据透视表是数据转换的常用方法。
6. 高级技巧：多级索引、时间序列处理、合并与连接和性能优化技巧可以提高数据分析的效率和灵活性。

DataFrame基础：DataFrame是Pandas中最重要的数据结构，类似于Excel表格或SQL表，由行和列组成。

数据创建：可以通过字典、列表、NumPy数组或从文件读取等多种方式创建DataFrame。

数据选择：使用loc（基于标签）、iloc（基于位置）和条件过滤等方法选择数据。

数据清洗：处理缺失值、重复值、异常值和数据类型转换是数据预处理的重要步骤。

数据转换：添加/删除列、应用函数、分组操作和数据透视表是数据转换的常用方法。

高级技巧：多级索引、时间序列处理、合并与连接和性能优化技巧可以提高数据分析的效率和灵活性。

最佳实践

1. 数据加载优化：对于大型文件，使用chunksize参数分块读取只加载需要的列，使用usecols参数指定适当的数据类型，减少内存使用
2. 对于大型文件，使用chunksize参数分块读取
3. 只加载需要的列，使用usecols参数
4. 指定适当的数据类型，减少内存使用

• 对于大型文件，使用chunksize参数分块读取
• 只加载需要的列，使用usecols参数
• 指定适当的数据类型，减少内存使用
  2. # 示例：优化大型CSV文件读取
  3. # 只加载需要的列，并指定数据类型
  4. dtypes = {'列1': 'int32', '列2': 'category', '列3': 'float32'}
  5. df = pd.read_csv('large_file.csv', usecols=['列1', '列2', '列3'], dtype=dtypes)
  7. # 分块读取大型文件
  8. chunk_size = 100000
  9. chunks = pd.read_csv('very_large_file.csv', chunksize=chunk_size)
  10. for chunk in chunks:
  11.     # 处理每个数据块
  12.     process(chunk)
复制代码

1. 内存优化：使用适当的数据类型（如int8代替int64）将字符串列转换为category类型（当唯一值较少时）使用downcast参数减少数值类型的内存占用
2. 使用适当的数据类型（如int8代替int64）
3. 将字符串列转换为category类型（当唯一值较少时）
4. 使用downcast参数减少数值类型的内存占用

• 使用适当的数据类型（如int8代替int64）
• 将字符串列转换为category类型（当唯一值较少时）
• 使用downcast参数减少数值类型的内存占用
  2. # 示例：内存优化
  3. def optimize_memory(df):
  4.     # 优化整数类型
  5.     int_cols = df.select_dtypes(include=['int64']).columns.tolist()
  6.     df[int_cols] = df[int_cols].apply(pd.to_numeric, downcast='integer')
  7.    
  8.     # 优化浮点类型
  9.     float_cols = df.select_dtypes(include=['float64']).columns.tolist()
  10.     df[float_cols] = df[float_cols].apply(pd.to_numeric, downcast='float')
  11.    
  12.     # 转换对象类型为category（当唯一值少于50%时）
  13.     obj_cols = df.select_dtypes(include=['object']).columns.tolist()
  14.     for col in obj_cols:
  15.         if df[col].nunique() / len(df[col]) < 0.5:
  16.             df[col] = df[col].astype('category')
  17.    
  18.     return df
  20. df_optimized = optimize_memory(df.copy())
  21. print("优化前内存使用:", df.memory_usage(deep=True).sum() / 1024**2, "MB")
  22. print("优化后内存使用:", df_optimized.memory_usage(deep=True).sum() / 1024**2, "MB")
复制代码

1. 性能优化：使用向量化操作代替循环使用eval和query方法进行高效计算和过滤使用itertuples代替iterrows进行行迭代
2. 使用向量化操作代替循环
3. 使用eval和query方法进行高效计算和过滤
4. 使用itertuples代替iterrows进行行迭代

• 使用向量化操作代替循环
• 使用eval和query方法进行高效计算和过滤
• 使用itertuples代替iterrows进行行迭代
  2. # 示例：性能优化
  3. # 向量化操作代替循环
  4. # 不好的方式
  5. for i in range(len(df)):
  6.     df.loc[i, '新列'] = df.loc[i, '列1'] * 2 + df.loc[i, '列2']
  8. # 好的方式
  9. df['新列'] = df['列1'] * 2 + df['列2']
  11. # 使用eval进行复杂计算
  12. df.eval('新列 = 列1 * 2 + 列2', inplace=True)
  14. # 使用query进行复杂过滤
  15. result = df.query('列1 > 10 and 列2 < 20')
  17. # 使用itertuples进行行迭代
  18. for row in df.itertuples():
  19.     # 处理每一行
  20.     process(row)
复制代码

1. 代码可读性与维护：使用有意义的列名和变量名将复杂操作分解为多个简单步骤添加注释解释关键步骤
2. 使用有意义的列名和变量名
3. 将复杂操作分解为多个简单步骤
4. 添加注释解释关键步骤

• 使用有意义的列名和变量名
• 将复杂操作分解为多个简单步骤
• 添加注释解释关键步骤
  2. # 示例：代码可读性与维护
  3. # 不好的方式
  4. df['c'] = df['a'] + df['b']
  5. d = df.groupby('c')['d'].mean().reset_index()
  7. # 好的方式
  8. # 计算两列之和
  9. df['sum_columns'] = df['column_a'] + df['column_b']
  11. # 按和分组并计算平均值
  12. average_by_sum = df.groupby('sum_columns')['value_column'].mean().reset_index()
  13. average_by_sum.rename(columns={'value_column': 'average_value'}, inplace=True)
复制代码

1. 链式操作：使用方法链式调用使代码更简洁适当时使用括号提高可读性
2. 使用方法链式调用使代码更简洁
3. 适当时使用括号提高可读性

• 使用方法链式调用使代码更简洁
• 适当时使用括号提高可读性
  2. # 示例：链式操作
  3. # 不好的方式
  4. df_filtered = df[df['value'] > 10]
  5. df_grouped = df_filtered.groupby('category')
  6. df_result = df_grouped.agg({'value': 'mean', 'count': 'sum'})
  8. # 好的方式
  9. df_result = (
  10.     df[df['value'] > 10]
  11.     .groupby('category')
  12.     .agg({'value': 'mean', 'count': 'sum'})
  13. )
复制代码

1. 错误处理：使用try-except块处理可能的异常检查数据质量和完整性
2. 使用try-except块处理可能的异常
3. 检查数据质量和完整性

• 使用try-except块处理可能的异常
• 检查数据质量和完整性
  2. # 示例：错误处理
  3. def safe_divide(a, b):
  4.     """安全除法，处理除零错误"""
  5.     try:
  6.         return a / b
  7.     except ZeroDivisionError:
  8.         return np.nan
  10. # 应用安全除法
  11. df['ratio'] = df.apply(lambda row: safe_divide(row['numerator'], row['denominator']), axis=1)
  13. # 检查数据质量
  14. def check_data_quality(df):
  15.     """检查数据质量并报告问题"""
  16.     issues = []
  17.    
  18.     # 检查缺失值
  19.     missing = df.isna().sum()
  20.     if missing.any():
  21.         issues.append(f"缺失值: {missing[missing > 0].to_dict()}")
  22.    
  23.     # 检查重复行
  24.     duplicates = df.duplicated().sum()
  25.     if duplicates > 0:
  26.         issues.append(f"重复行: {duplicates}")
  27.    
  28.     # 检查异常值（使用IQR方法）
  29.     numeric_cols = df.select_dtypes(include=['number']).columns
  30.     for col in numeric_cols:
  31.         Q1 = df[col].quantile(0.25)
  32.         Q3 = df[col].quantile(0.75)
  33.         IQR = Q3 - Q1
  34.         outliers = ((df[col] < (Q1 - 1.5 * IQR)) | (df[col] > (Q3 + 1.5 * IQR))).sum()
  35.         if outliers > 0:
  36.             issues.append(f"列 {col} 中发现 {outliers} 个异常值")
  37.    
  38.     return issues
  40. quality_issues = check_data_quality(df)
  41. if quality_issues:
  42.     print("数据质量问题:")
  43.     for issue in quality_issues:
  44.         print(f"- {issue}")
  45. else:
  46.     print("未发现明显的数据质量问题")
复制代码

通过遵循这些最佳实践，你可以更高效地使用Pandas DataFrame进行数据处理和分析，同时保持代码的可读性和可维护性。随着经验的积累，你将能够更加熟练地运用这些技巧，成为真正的数据处理高手。
数据结构, 数据处理, 解析, 高手
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

返回列表 发新帖
您需要登录后才可以回帖 登录 | 立即注册
高级模式
B Color Image Link Quote Code Smilies

本版积分规则

友情链接

keba
磕巴白菜
别管 别听 就是玩
二次元论坛
二次元论坛
按下F逃离世界！
友链交换
友链交换
友链为随机排序，不代表本论坛观点
加入Discord频道

加入Discord频道

加入QQ社群

加入QQ社群

联系我们|小黑屋|TG频道|RSS |网站地图

Powered by Pixtech

© 2025-2026 Pixtech Team.