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

开启辅助访问 切换到宽版

站内搜索

搜索

活动公告

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

深入浅出Pandas库在Python数据分析中的应用实例与实战技巧助你轻松掌握数据处理技能提升工作效率解决实际问题

威震华夏关云长
SunJu_FaceMall

3万

主题

166

科技点

3万

积分

大区版主

碾压王

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

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

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

x
引言

Pandas是Python语言中用于数据分析的强大工具库，它提供了高性能、易于使用的数据结构和数据分析工具。自2008年由Wes McKinney创建以来，Pandas已经成为数据科学家、分析师和研究人员不可或缺的工具。Pandas建立在NumPy之上，提供了更高级的数据操作功能，使得数据清洗、转换、分析和可视化变得更加简单和高效。

在当今数据驱动的世界中，处理和分析数据的能力变得越来越重要。Pandas库凭借其灵活性和功能性，能够帮助我们处理各种类型的数据，从简单的表格数据到复杂的时间序列数据。本文将深入浅出地介绍Pandas库的核心功能，通过实际应用实例和实战技巧，帮助读者轻松掌握数据处理技能，提升工作效率，解决实际问题。

Pandas基础

数据结构

Pandas库提供了两种主要的数据结构：Series和DataFrame。

Series是一种一维标记数组结构，能够保存任何数据类型（整数、字符串、浮点数、Python对象等）。Series类似于带标签的NumPy数组，可以通过索引访问数据。
  2. import pandas as pd
  3. import numpy as np
  5. # 创建一个Series
  6. s = pd.Series([1, 3, 5, np.nan, 6, 8])
  7. print(s)
  9. # 带索引的Series
  10. s = pd.Series([1, 3, 5, np.nan, 6, 8], index=['a', 'b', 'c', 'd', 'e', 'f'])
  11. print(s)
  13. # 通过字典创建Series
  14. d = {'a': 1, 'b': 2, 'c': 3}
  15. s = pd.Series(d)
  16. print(s)
复制代码

DataFrame是二维标记数据结构，类似于电子表格或SQL表格。它由列组成，每列可以是不同的数据类型。DataFrame是Pandas中最常用的数据结构，适合处理表格数据。
  2. # 创建一个DataFrame
  3. data = {
  4.     'Name': ['Alice', 'Bob', 'Charlie', 'David'],
  5.     'Age': [25, 30, 35, 40],
  6.     'City': ['New York', 'Los Angeles', 'Chicago', 'Houston']
  7. }
  8. df = pd.DataFrame(data)
  9. print(df)
  11. # 从NumPy数组创建DataFrame
  12. array = np.random.rand(5, 3)
  13. df = pd.DataFrame(array, columns=['A', 'B', 'C'])
  14. print(df)
复制代码

基本操作
  2. # 查看前几行数据
  3. print(df.head())
  5. # 查看后几行数据
  6. print(df.tail())
  8. # 查看数据的基本信息
  9. print(df.info())
  11. # 查看数据的统计摘要
  12. print(df.describe())
  14. # 查看数据的形状（行数和列数）
  15. print(df.shape)
复制代码
  2. # 选择单列
  3. print(df['Name'])
  5. # 选择多列
  6. print(df[['Name', 'Age']])
  8. # 使用iloc选择行（基于位置）
  9. print(df.iloc[0])  # 第一行
  10. print(df.iloc[0:2])  # 前两行
  12. # 使用loc选择行（基于标签）
  13. print(df.loc[0])  # 第一行
  14. print(df.loc[0:1])  # 第一行
  16. # 条件选择
  17. print(df[df['Age'] > 30])
复制代码

数据导入与导出

在实际数据分析工作中，数据通常存储在各种格式的文件中，如CSV、Excel、SQL数据库等。Pandas提供了多种函数来读取和写入这些格式的数据。

读取数据
  2. # 读取CSV文件
  3. df = pd.read_csv('data.csv')
  5. # 指定分隔符
  6. df = pd.read_csv('data.csv', sep=';')
  8. # 指定编码
  9. df = pd.read_csv('data.csv', encoding='utf-8')
  11. # 指定列名
  12. df = pd.read_csv('data.csv', names=['col1', 'col2', 'col3'])
  14. # 只读取前n行
  15. df = pd.read_csv('data.csv', nrows=100)
  17. # 跳过前n行
  18. df = pd.read_csv('data.csv', skiprows=2)
复制代码
  2. # 读取Excel文件
  3. df = pd.read_excel('data.xlsx')
  5. # 指定工作表
  6. df = pd.read_excel('data.xlsx', sheet_name='Sheet2')
  8. # 指定列
  9. df = pd.read_excel('data.xlsx', usecols=['Name', 'Age'])
复制代码
  2. import sqlite3
  4. # 创建数据库连接
  5. conn = sqlite3.connect('database.db')
  7. # 从SQL查询读取数据
  8. df = pd.read_sql('SELECT * FROM table_name', conn)
  10. # 关闭连接
  11. conn.close()
复制代码

写入数据
  2. # 写入CSV文件
  3. df.to_csv('output.csv', index=False)
  5. # 写入Excel文件
  6. df.to_excel('output.xlsx', sheet_name='Sheet1', index=False)
  8. # 写入SQL数据库
  9. conn = sqlite3.connect('database.db')
  10. df.to_sql('table_name', conn, if_exists='replace', index=False)
  11. conn.close()
复制代码

数据清洗

数据清洗是数据分析过程中至关重要的一步，它涉及处理缺失值、重复值、异常值等，以确保数据的质量和准确性。

处理缺失值
  2. # 检查缺失值
  3. print(df.isnull())
  5. # 计算每列的缺失值数量
  6. print(df.isnull().sum())
  8. # 删除含有缺失值的行
  9. df_cleaned = df.dropna()
  11. # 删除全为缺失值的行
  12. df_cleaned = df.dropna(how='all')
  14. # 删除含有缺失值的列
  15. df_cleaned = df.dropna(axis=1)
  17. # 填充缺失值
  18. df_filled = df.fillna(0)  # 用0填充
  19. df_filled = df.fillna(method='ffill')  # 用前一个值填充
  20. df_filled = df.fillna(method='bfill')  # 用后一个值填充
  21. df_filled = df.fillna({'column1': 0, 'column2': 'missing'})  # 按列指定填充值
  23. # 使用均值填充
  24. mean_value = df['column_name'].mean()
  25. df['column_name'].fillna(mean_value, inplace=True)
复制代码

处理重复值
  2. # 检查重复行
  3. print(df.duplicated())
  5. # 计算重复行的数量
  6. print(df.duplicated().sum())
  8. # 删除重复行
  9. df_unique = df.drop_duplicates()
  11. # 基于特定列删除重复行
  12. df_unique = df.drop_duplicates(subset=['column_name'])
  14. # 保留最后一个重复行
  15. df_unique = df.drop_duplicates(keep='last')
复制代码

处理异常值
  2. # 使用Z分数检测异常值
  3. from scipy import stats
  5. z_scores = stats.zscore(df['column_name'])
  6. abs_z_scores = np.abs(z_scores)
  7. filtered_entries = (abs_z_scores < 3)
  8. df_filtered = df[filtered_entries]
  10. # 使用IQR（四分位距）检测异常值
  11. Q1 = df['column_name'].quantile(0.25)
  12. Q3 = df['column_name'].quantile(0.75)
  13. IQR = Q3 - Q1
  14. lower_bound = Q1 - 1.5 * IQR
  15. upper_bound = Q3 + 1.5 * IQR
  16. df_filtered = df[(df['column_name'] >= lower_bound) & (df['column_name'] <= upper_bound)]
  18. # 替换异常值
  19. df['column_name'] = np.where(df['column_name'] > upper_bound, upper_bound,
  20.                             np.where(df['column_name'] < lower_bound, lower_bound, df['column_name']))
复制代码

数据类型转换
  2. # 查看数据类型
  3. print(df.dtypes)
  5. # 转换数据类型
  6. df['column_name'] = df['column_name'].astype('int64')
  7. df['column_name'] = df['column_name'].astype('float64')
  8. df['column_name'] = df['column_name'].astype('category')
  9. df['column_name'] = df['column_name'].astype('datetime64[ns]')
  11. # 转换日期
  12. df['date_column'] = pd.to_datetime(df['date_column'])
复制代码

数据探索与预处理

在数据清洗之后，下一步是进行数据探索和预处理，以更好地理解数据并为后续分析做准备。

描述性统计
  2. # 基本统计信息
  3. print(df.describe())
  5. # 计算特定列的统计量
  6. print(df['column_name'].mean())  # 均值
  7. print(df['column_name'].median())  # 中位数
  8. print(df['column_name'].mode())  # 众数
  9. print(df['column_name'].std())  # 标准差
  10. print(df['column_name'].var())  # 方差
  11. print(df['column_name'].min())  # 最小值
  12. print(df['column_name'].max())  # 最大值
  13. print(df['column_name'].quantile([0.25, 0.5, 0.75]))  # 分位数
  15. # 计算相关性
  16. print(df.corr())
  18. # 计算协方差
  19. print(df.cov())
复制代码

数据转换
  2. # 标准化数据
  3. from sklearn.preprocessing import StandardScaler
  5. scaler = StandardScaler()
  6. df['column_name_scaled'] = scaler.fit_transform(df[['column_name']])
  8. # 归一化数据
  9. from sklearn.preprocessing import MinMaxScaler
  11. scaler = MinMaxScaler()
  12. df['column_name_normalized'] = scaler.fit_transform(df[['column_name']])
  14. # 对数转换
  15. df['column_name_log'] = np.log(df['column_name'])
  17. # 平方根转换
  18. df['column_name_sqrt'] = np.sqrt(df['column_name'])
  20. # 哑变量/独热编码
  21. df_dummies = pd.get_dummies(df['column_name'], prefix='prefix')
  22. df = pd.concat([df, df_dummies], axis=1)
  24. # 标签编码
  25. from sklearn.preprocessing import LabelEncoder
  27. le = LabelEncoder()
  28. df['column_name_encoded'] = le.fit_transform(df['column_name'])
复制代码

特征工程
  2. # 创建新特征
  3. df['new_feature'] = df['feature1'] + df['feature2']
  4. df['new_feature'] = df['feature1'] * df['feature2']
  5. df['new_feature'] = df['feature1'] / df['feature2']
  7. # 分箱
  8. df['binned'] = pd.cut(df['column_name'], bins=3, labels=['low', 'medium', 'high'])
  10. # 从日期提取特征
  11. df['year'] = df['date_column'].dt.year
  12. df['month'] = df['date_column'].dt.month
  13. df['day'] = df['date_column'].dt.day
  14. df['weekday'] = df['date_column'].dt.weekday
复制代码

数据分组与聚合

数据分组与聚合是数据分析中常用的操作，可以帮助我们理解数据的不同子集的特征。

GroupBy操作
  2. # 按单列分组
  3. grouped = df.groupby('column_name')
  5. # 计算每组的统计量
  6. print(grouped.mean())
  7. print(grouped.sum())
  8. print(grouped.count())
  9. print(grouped.max())
  10. print(grouped.min())
  12. # 按多列分组
  13. grouped = df.groupby(['column1', 'column2'])
  15. # 应用多个聚合函数
  16. print(grouped.agg(['mean', 'sum', 'count']))
  18. # 对不同列应用不同聚合函数
  19. print(grouped.agg({
  20.     'column1': 'mean',
  21.     'column2': 'sum',
  22.     'column3': 'count'
  23. }))
  25. # 自定义聚合函数
  26. def custom_func(x):
  27.     return x.max() - x.min()
  29. print(grouped.agg(custom_func))
  31. # 迭代分组
  32. for name, group in grouped:
  33.     print(name)
  34.     print(group.head())
复制代码

透视表
  2. # 创建透视表
  3. pivot = pd.pivot_table(df, values='value_column', index='row_column', columns='column_column', aggfunc='mean')
  4. print(pivot)
  6. # 多个聚合函数
  7. pivot = pd.pivot_table(df, values='value_column', index='row_column', columns='column_column',
  8.                       aggfunc=['mean', 'sum', 'count'])
  9. print(pivot)
  11. # 多个值列
  12. pivot = pd.pivot_table(df, values=['value_column1', 'value_column2'], index='row_column',
  13.                       columns='column_column', aggfunc='mean')
  14. print(pivot)
  16. # 添加边际
  17. pivot = pd.pivot_table(df, values='value_column', index='row_column', columns='column_column',
  18.                       aggfunc='mean', margins=True)
  19. print(pivot)
复制代码

交叉表
  2. # 创建交叉表
  3. cross = pd.crosstab(df['column1'], df['column2'])
  4. print(cross)
  6. # 归一化
  7. cross = pd.crosstab(df['column1'], df['column2'], normalize='index')
  8. print(cross)
  10. # 添加边际
  11. cross = pd.crosstab(df['column1'], df['column2'], margins=True)
  12. print(cross)
复制代码

数据合并与重塑

在实际数据分析中，我们经常需要合并多个数据集或重塑数据以适应分析需求。

Merge操作
  2. # 创建两个DataFrame
  3. df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'], 'value': [1, 2, 3, 4]})
  4. df2 = pd.DataFrame({'key': ['B', 'D', 'E', 'F'], 'value': [5, 6, 7, 8]})
  6. # 内连接
  7. merged_inner = pd.merge(df1, df2, on='key', how='inner')
  8. print(merged_inner)
  10. # 左连接
  11. merged_left = pd.merge(df1, df2, on='key', how='left')
  12. print(merged_left)
  14. # 右连接
  15. merged_right = pd.merge(df1, df2, on='key', how='right')
  16. print(merged_right)
  18. # 外连接
  19. merged_outer = pd.merge(df1, df2, on='key', how='outer')
  20. print(merged_outer)
  22. # 基于多列合并
  23. df1 = pd.DataFrame({'key1': ['A', 'B', 'C', 'D'], 'key2': ['K', 'L', 'M', 'N'], 'value': [1, 2, 3, 4]})
  24. df2 = pd.DataFrame({'key1': ['B', 'D', 'E', 'F'], 'key2': ['L', 'N', 'O', 'P'], 'value': [5, 6, 7, 8]})
  25. merged = pd.merge(df1, df2, on=['key1', 'key2'], how='inner')
  26. print(merged)
  28. # 列名不同时的合并
  29. df1 = pd.DataFrame({'key': ['A', 'B', 'C', 'D'], 'value': [1, 2, 3, 4]})
  30. df2 = pd.DataFrame({'other_key': ['B', 'D', 'E', 'F'], 'value': [5, 6, 7, 8]})
  31. merged = pd.merge(df1, df2, left_on='key', right_on='other_key', how='inner')
  32. print(merged)
复制代码

Join操作
  2. # 创建两个DataFrame
  3. df1 = pd.DataFrame({'value': [1, 2, 3, 4]}, index=['A', 'B', 'C', 'D'])
  4. df2 = pd.DataFrame({'value': [5, 6, 7, 8]}, index=['B', 'D', 'E', 'F'])
  6. # 内连接
  7. joined_inner = df1.join(df2, how='inner', lsuffix='_left', rsuffix='_right')
  8. print(joined_inner)
  10. # 左连接
  11. joined_left = df1.join(df2, how='left', lsuffix='_left', rsuffix='_right')
  12. print(joined_left)
  14. # 右连接
  15. joined_right = df1.join(df2, how='right', lsuffix='_left', rsuffix='_right')
  16. print(joined_right)
  18. # 外连接
  19. joined_outer = df1.join(df2, how='outer', lsuffix='_left', rsuffix='_right')
  20. print(joined_outer)
复制代码

Concatenate操作
  2. # 创建两个DataFrame
  3. df1 = pd.DataFrame({'A': ['A0', 'A1', 'A2'], 'B': ['B0', 'B1', 'B2']})
  4. df2 = pd.DataFrame({'A': ['A3', 'A4', 'A5'], 'B': ['B3', 'B4', 'B5']})
  6. # 垂直连接
  7. concat_vertical = pd.concat([df1, df2], axis=0)
  8. print(concat_vertical)
  10. # 水平连接
  11. concat_horizontal = pd.concat([df1, df2], axis=1)
  12. print(concat_horizontal)
  14. # 忽略索引
  15. concat_ignore_index = pd.concat([df1, df2], axis=0, ignore_index=True)
  16. print(concat_ignore_index)
  18. # 添加键以识别来源
  19. concat_keys = pd.concat([df1, df2], axis=0, keys=['df1', 'df2'])
  20. print(concat_keys)
复制代码

重塑数据
  2. # 创建DataFrame
  3. df = pd.DataFrame({
  4.     'date': ['2022-01-01', '2022-01-01', '2022-01-02', '2022-01-02'],
  5.     'variable': ['A', 'B', 'A', 'B'],
  6.     'value': [1, 2, 3, 4]
  7. })
  9. # 从长格式转换为宽格式
  10. pivot = df.pivot(index='date', columns='variable', values='value')
  11. print(pivot)
  13. # 从宽格式转换为长格式
  14. melted = pd.melt(pivot.reset_index(), id_vars='date', value_vars=['A', 'B'],
  15.                 var_name='variable', value_name='value')
  16. print(melted)
  18. # 使用stack和unstack
  19. stacked = pivot.stack()
  20. print(stacked)
  22. unstacked = stacked.unstack()
  23. print(unstacked)
复制代码

时间序列分析

Pandas提供了强大的时间序列分析功能，使我们能够轻松处理时间数据。

创建时间序列
  2. # 创建时间范围
  3. dates = pd.date_range('20220101', periods=10)
  4. print(dates)
  6. # 创建时间序列DataFrame
  7. ts = pd.DataFrame(np.random.randn(10, 4), index=dates, columns=list('ABCD'))
  8. print(ts)
  10. # 指定频率
  11. dates = pd.date_range('20220101', periods=10, freq='D')  # 日频率
  12. dates = pd.date_range('20220101', periods=10, freq='M')  # 月频率
  13. dates = pd.date_range('20220101', periods=10, freq='Y')  # 年频率
  14. dates = pd.date_range('20220101', periods=10, freq='H')  # 小时频率
复制代码

时间序列操作
  2. # 选择特定时间范围的数据
  3. print(ts['2022-01-01':'2022-01-05'])
  5. # 按年份选择
  6. print(ts['2022'])
  8. # 按月份选择
  9. print(ts['2022-01'])
  11. # 重采样
  12. # 按月重采样，计算均值
  13. monthly = ts.resample('M').mean()
  14. print(monthly)
  16. # 按周重采样，计算总和
  17. weekly = ts.resample('W').sum()
  18. print(weekly)
  20. # 滚动窗口
  21. # 计算滚动均值
  22. rolling_mean = ts.rolling(window=3).mean()
  23. print(rolling_mean)
  25. # 计算滚动标准差
  26. rolling_std = ts.rolling(window=3).std()
  27. print(rolling_std)
  29. # 计算滚动最大值
  30. rolling_max = ts.rolling(window=3).max()
  31. print(rolling_max)
  33. # 计算滚动最小值
  34. rolling_min = ts.rolling(window=3).min()
  35. print(rolling_min)
  37. # 时间差
  38. ts['time_diff'] = ts.index.to_series().diff()
  39. print(ts['time_diff'])
复制代码

时间序列可视化
  2. import matplotlib.pyplot as plt
  4. # 绘制时间序列
  5. ts['A'].plot(figsize=(12, 6))
  6. plt.title('Time Series Plot')
  7. plt.xlabel('Date')
  8. plt.ylabel('Value')
  9. plt.grid(True)
  10. plt.show()
  12. # 绘制滚动均值
  13. ts['A'].plot(figsize=(12, 6), label='Original')
  14. ts['A'].rolling(window=3).mean().plot(label='Rolling Mean (3 days)')
  15. plt.title('Time Series with Rolling Mean')
  16. plt.xlabel('Date')
  17. plt.ylabel('Value')
  18. plt.legend()
  19. plt.grid(True)
  20. plt.show()
  22. # 绘制季节性分解
  23. from statsmodels.tsa.seasonal import seasonal_decompose
  25. decomposition = seasonal_decompose(ts['A'], model='additive', period=3)
  26. fig = decomposition.plot()
  27. fig.set_size_inches(12, 8)
  28. plt.show()
复制代码

数据可视化

Pandas内置了数据可视化功能，基于Matplotlib库，使我们能够轻松创建各种类型的图表。

基本图表
  2. # 创建示例数据
  3. df = pd.DataFrame({
  4.     'A': np.random.randn(100).cumsum(),
  5.     'B': np.random.randn(100).cumsum(),
  6.     'C': np.random.randn(100).cumsum()
  7. }, index=pd.date_range('20220101', periods=100))
  9. # 折线图
  10. df.plot(figsize=(12, 6))
  11. plt.title('Line Plot')
  12. plt.xlabel('Date')
  13. plt.ylabel('Value')
  14. plt.grid(True)
  15. plt.show()
  17. # 柱状图
  18. df.iloc[0:10].plot(kind='bar', figsize=(12, 6))
  19. plt.title('Bar Plot')
  20. plt.xlabel('Date')
  21. plt.ylabel('Value')
  22. plt.grid(True)
  23. plt.show()
  25. # 水平柱状图
  26. df.iloc[0:10].plot(kind='barh', figsize=(12, 6))
  27. plt.title('Horizontal Bar Plot')
  28. plt.xlabel('Value')
  29. plt.ylabel('Date')
  30. plt.grid(True)
  31. plt.show()
  33. # 直方图
  34. df['A'].plot(kind='hist', bins=20, figsize=(12, 6))
  35. plt.title('Histogram')
  36. plt.xlabel('Value')
  37. plt.ylabel('Frequency')
  38. plt.grid(True)
  39. plt.show()
  41. # 密度图
  42. df['A'].plot(kind='density', figsize=(12, 6))
  43. plt.title('Density Plot')
  44. plt.xlabel('Value')
  45. plt.ylabel('Density')
  46. plt.grid(True)
  47. plt.show()
  49. # 箱线图
  50. df.plot(kind='box', figsize=(12, 6))
  51. plt.title('Box Plot')
  52. plt.ylabel('Value')
  53. plt.grid(True)
  54. plt.show()
  56. # 散点图
  57. df.plot(kind='scatter', x='A', y='B', figsize=(12, 6))
  58. plt.title('Scatter Plot')
  59. plt.grid(True)
  60. plt.show()
  62. # 饼图
  63. df.iloc[0].plot(kind='pie', figsize=(8, 8), autopct='%1.1f%%')
  64. plt.title('Pie Plot')
  65. plt.show()
复制代码

高级可视化
  2. # 创建示例数据
  3. df = pd.DataFrame({
  4.     'x': np.random.randn(100),
  5.     'y': np.random.randn(100),
  6.     'category': np.random.choice(['A', 'B', 'C'], 100)
  7. })
  9. # 分组散点图
  10. groups = df.groupby('category')
  11. fig, ax = plt.subplots(figsize=(12, 6))
  12. for name, group in groups:
  13.     ax.plot(group.x, group.y, marker='o', linestyle='', ms=8, label=name)
  14. ax.legend()
  15. plt.title('Grouped Scatter Plot')
  16. plt.xlabel('x')
  17. plt.ylabel('y')
  18. plt.grid(True)
  19. plt.show()
  21. # 热力图
  22. corr = df.corr()
  23. plt.figure(figsize=(8, 6))
  24. plt.imshow(corr, cmap='coolwarm', vmin=-1, vmax=1)
  25. plt.colorbar()
  26. plt.title('Correlation Heatmap')
  27. plt.xticks(range(len(corr)), corr.columns, rotation=45)
  28. plt.yticks(range(len(corr)), corr.columns)
  29. plt.show()
  31. # 平行坐标图
  32. from pandas.plotting import parallel_coordinates
  34. df = pd.DataFrame({
  35.     'A': np.random.rand(30),
  36.     'B': np.random.rand(30),
  37.     'C': np.random.rand(30),
  38.     'D': np.random.rand(30),
  39.     'E': np.random.choice(['X', 'Y', 'Z'], 30)
  40. })
  41. plt.figure(figsize=(12, 6))
  42. parallel_coordinates(df, 'E', colormap='viridis')
  43. plt.title('Parallel Coordinates Plot')
  44. plt.grid(True)
  45. plt.show()
  47. # 安德鲁斯曲线
  48. from pandas.plotting import andrews_curves
  50. plt.figure(figsize=(12, 6))
  51. andrews_curves(df, 'E', colormap='viridis')
  52. plt.title('Andrews Curves')
  53. plt.grid(True)
  54. plt.show()
复制代码

实战案例

案例1：销售数据分析

假设我们有一个销售数据集，包含日期、产品、销售额等信息。我们将使用Pandas进行数据分析，找出销售趋势、热门产品和季节性模式。
  2. # 创建示例数据
  3. np.random.seed(42)
  4. dates = pd.date_range('20210101', '20211231')
  5. products = ['A', 'B', 'C', 'D', 'E']
  6. regions = ['North', 'South', 'East', 'West']
  8. data = []
  9. for date in dates:
  10.     for product in products:
  11.         for region in regions:
  12.             sales = np.random.randint(100, 1000)
  13.             data.append([date, product, region, sales])
  15. df = pd.DataFrame(data, columns=['Date', 'Product', 'Region', 'Sales'])
  17. # 查看数据
  18. print(df.head())
  19. print(df.info())
  21. # 按月份分析销售额
  22. df['Month'] = df['Date'].dt.to_period('M')
  23. monthly_sales = df.groupby('Month')['Sales'].sum().reset_index()
  24. monthly_sales['Month'] = monthly_sales['Month'].dt.to_timestamp()
  26. plt.figure(figsize=(12, 6))
  27. plt.plot(monthly_sales['Month'], monthly_sales['Sales'])
  28. plt.title('Monthly Sales Trend')
  29. plt.xlabel('Month')
  30. plt.ylabel('Sales')
  31. plt.grid(True)
  32. plt.show()
  34. # 按产品分析销售额
  35. product_sales = df.groupby('Product')['Sales'].sum().reset_index()
  37. plt.figure(figsize=(10, 6))
  38. plt.bar(product_sales['Product'], product_sales['Sales'])
  39. plt.title('Sales by Product')
  40. plt.xlabel('Product')
  41. plt.ylabel('Sales')
  42. plt.grid(True)
  43. plt.show()
  45. # 按地区分析销售额
  46. region_sales = df.groupby('Region')['Sales'].sum().reset_index()
  48. plt.figure(figsize=(10, 6))
  49. plt.bar(region_sales['Region'], region_sales['Sales'])
  50. plt.title('Sales by Region')
  51. plt.xlabel('Region')
  52. plt.ylabel('Sales')
  53. plt.grid(True)
  54. plt.show()
  56. # 产品和地区的交叉分析
  57. pivot = pd.pivot_table(df, values='Sales', index='Product', columns='Region', aggfunc='sum')
  59. plt.figure(figsize=(10, 6))
  60. sns.heatmap(pivot, annot=True, fmt='d', cmap='YlGnBu')
  61. plt.title('Sales by Product and Region')
  62. plt.show()
  64. # 季节性分析
  65. df['Quarter'] = df['Date'].dt.quarter
  66. quarterly_sales = df.groupby(['Product', 'Quarter'])['Sales'].sum().reset_index()
  68. plt.figure(figsize=(12, 6))
  69. for product in products:
  70.     data = quarterly_sales[quarterly_sales['Product'] == product]
  71.     plt.plot(data['Quarter'], data['Sales'], marker='o', label=product)
  72. plt.title('Quarterly Sales by Product')
  73. plt.xlabel('Quarter')
  74. plt.ylabel('Sales')
  75. plt.legend()
  76. plt.grid(True)
  77. plt.show()
复制代码

案例2：金融数据分析

在这个案例中，我们将使用Pandas分析股票价格数据，计算收益率、波动率，并进行简单的技术分析。
  2. # 安装yfinance库获取股票数据
  3. # pip install yfinance
  4. import yfinance as yf
  6. # 获取股票数据
  7. tickers = ['AAPL', 'MSFT', 'GOOG', 'AMZN']
  8. start_date = '2020-01-01'
  9. end_date = '2021-12-31'
  11. data = yf.download(tickers, start=start_date, end=end_date)['Adj Close']
  13. # 查看数据
  14. print(data.head())
  16. # 计算日收益率
  17. returns = data.pct_change().dropna()
  19. # 查看收益率
  20. print(returns.head())
  22. # 绘制价格走势
  23. plt.figure(figsize=(12, 6))
  24. for ticker in tickers:
  25.     plt.plot(data.index, data[ticker], label=ticker)
  26. plt.title('Stock Price Trend')
  27. plt.xlabel('Date')
  28. plt.ylabel('Price')
  29. plt.legend()
  30. plt.grid(True)
  31. plt.show()
  33. # 绘制收益率分布
  34. plt.figure(figsize=(12, 6))
  35. for ticker in tickers:
  36.     plt.hist(returns[ticker], bins=50, alpha=0.5, label=ticker)
  37. plt.title('Distribution of Daily Returns')
  38. plt.xlabel('Return')
  39. plt.ylabel('Frequency')
  40. plt.legend()
  41. plt.grid(True)
  42. plt.show()
  44. # 计算并绘制滚动均值和标准差
  45. window = 20
  47. for ticker in tickers:
  48.     fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8), sharex=True)
  49.    
  50.     # 价格和滚动均值
  51.     ax1.plot(data.index, data[ticker], label='Price')
  52.     ax1.plot(data.index, data[ticker].rolling(window=window).mean(), label=f'{window}-day Moving Average')
  53.     ax1.set_title(f'{ticker} Price and Moving Average')
  54.     ax1.set_ylabel('Price')
  55.     ax1.legend()
  56.     ax1.grid(True)
  57.    
  58.     # 滚动标准差（波动率）
  59.     ax2.plot(returns.index, returns[ticker].rolling(window=window).std(), label=f'{window}-day Volatility')
  60.     ax2.set_title(f'{ticker} Volatility')
  61.     ax2.set_xlabel('Date')
  62.     ax2.set_ylabel('Volatility')
  63.     ax2.legend()
  64.     ax2.grid(True)
  65.    
  66.     plt.tight_layout()
  67.     plt.show()
  69. # 计算相关系数
  70. corr = returns.corr()
  72. plt.figure(figsize=(8, 6))
  73. plt.imshow(corr, cmap='coolwarm', vmin=-1, vmax=1)
  74. plt.colorbar()
  75. plt.title('Correlation Matrix of Returns')
  76. plt.xticks(range(len(corr)), corr.columns, rotation=45)
  77. plt.yticks(range(len(corr)), corr.columns)
  78. for i in range(len(corr)):
  79.     for j in range(len(corr)):
  80.         plt.text(j, i, f'{corr.iloc[i, j]:.2f}', ha='center', va='center', color='white')
  81. plt.show()
  83. # 计算累计收益率
  84. cumulative_returns = (1 + returns).cumprod()
  86. plt.figure(figsize=(12, 6))
  87. for ticker in tickers:
  88.     plt.plot(cumulative_returns.index, cumulative_returns[ticker], label=ticker)
  89. plt.title('Cumulative Returns')
  90. plt.xlabel('Date')
  91. plt.ylabel('Cumulative Return')
  92. plt.legend()
  93. plt.grid(True)
  94. plt.show()
复制代码

案例3：客户行为分析

在这个案例中，我们将分析客户行为数据，包括购买历史、网站活动等，以识别客户群体和购买模式。
  2. # 创建示例数据
  3. np.random.seed(42)
  4. n_customers = 1000
  5. n_transactions = 5000
  7. customer_ids = range(1, n_customers + 1)
  8. product_categories = ['Electronics', 'Clothing', 'Home', 'Beauty', 'Sports']
  9. regions = ['North', 'South', 'East', 'West']
  10. payment_methods = ['Credit Card', 'PayPal', 'Bank Transfer', 'Cash']
  12. # 生成交易数据
  13. transactions = []
  14. for _ in range(n_transactions):
  15.     customer_id = np.random.choice(customer_ids)
  16.     date = pd.Timestamp('2021-01-01') + pd.Timedelta(days=np.random.randint(0, 365))
  17.     product_category = np.random.choice(product_categories)
  18.     region = np.random.choice(regions)
  19.     payment_method = np.random.choice(payment_methods)
  20.     amount = np.random.uniform(10, 500)
  21.    
  22.     transactions.append([customer_id, date, product_category, region, payment_method, amount])
  24. df = pd.DataFrame(transactions, columns=['CustomerID', 'Date', 'ProductCategory', 'Region', 'PaymentMethod', 'Amount'])
  26. # 查看数据
  27. print(df.head())
  28. print(df.info())
  30. # 客户细分：计算每个客户的总购买金额和购买次数
  31. customer_stats = df.groupby('CustomerID').agg({
  32.     'Amount': ['sum', 'mean', 'count'],
  33.     'Date': ['min', 'max']
  34. }).reset_index()
  36. # 扁平化多级列索引
  37. customer_stats.columns = ['CustomerID', 'TotalAmount', 'AvgAmount', 'TransactionCount', 'FirstPurchase', 'LastPurchase']
  39. # 计算客户活跃天数
  40. customer_stats['ActiveDays'] = (customer_stats['LastPurchase'] - customer_stats['FirstPurchase']).dt.days + 1
  42. # 计算平均购买频率（天）
  43. customer_stats['AvgPurchaseFrequency'] = customer_stats['ActiveDays'] / customer_stats['TransactionCount']
  45. print(customer_stats.head())
  47. # 客户RFM分析（Recency, Frequency, Monetary）
  48. # 假设分析日期是数据的最后一天
  49. analysis_date = df['Date'].max()
  51. # 计算Recency（最近一次购买距离分析日期的天数）
  52. recency = df.groupby('CustomerID')['Date'].max().reset_index()
  53. recency['Recency'] = (analysis_date - recency['Date']).dt.days
  55. # 计算Frequency（购买次数）
  56. frequency = df.groupby('CustomerID')['Date'].count().reset_index()
  57. frequency.columns = ['CustomerID', 'Frequency']
  59. # 计算Monetary（总购买金额）
  60. monetary = df.groupby('CustomerID')['Amount'].sum().reset_index()
  61. monetary.columns = ['CustomerID', 'Monetary']
  63. # 合并RFM指标
  64. rfm = pd.merge(recency[['CustomerID', 'Recency']], frequency, on='CustomerID')
  65. rfm = pd.merge(rfm, monetary, on='CustomerID')
  67. # 为RFM指标打分（1-5分，5分最好）
  68. rfm['R_Score'] = pd.qcut(rfm['Recency'], 5, labels=[5, 4, 3, 2, 1])
  69. rfm['F_Score'] = pd.qcut(rfm['Frequency'].rank(method='first'), 5, labels=[1, 2, 3, 4, 5])
  70. rfm['M_Score'] = pd.qcut(rfm['Monetary'], 5, labels=[1, 2, 3, 4, 5])
  72. # 计算RFM综合得分
  73. rfm['RFM_Score'] = rfm['R_Score'].astype(str) + rfm['F_Score'].astype(str) + rfm['M_Score'].astype(str)
  75. # 客户细分
  76. def segment_customer(df):
  77.     if df['RFM_Score'] in ['555', '554', '544', '545', '454', '455', '445']:
  78.         return 'Champions'
  79.     elif df['RFM_Score'] in ['543', '444', '435', '355', '354', '345', '344', '335']:
  80.         return 'Loyal Customers'
  81.     elif df['RFM_Score'] in ['512', '511', '422', '421', '412', '411', '311']:
  82.         return 'Potential Loyalists'
  83.     elif df['RFM_Score'] in ['525', '524', '523', '522', '521', '515', '514', '513']:
  84.         return 'New Customers'
  85.     elif df['RFM_Score'] in ['155', '154', '144', '214', '215', '115', '114']:
  86.         return 'At Risk'
  87.     elif df['RFM_Score'] in ['255', '254', '245', '244', '253', '252', '243', '242', '235', '234', '225', '224', '153', '152', '145', '143', '142', '135', '134', '133', '125', '124']:
  88.         return 'Cannot Lose Them'
  89.     elif df['RFM_Score'] in ['331', '321', '312', '221', '213', '231', '241', '251']:
  90.         return 'About To Sleep'
  91.     elif df['RFM_Score'] in ['332', '322', '233', '232', '223', '222', '132', '123', '122', '212', '211']:
  92.         return 'Need Attention'
  93.     elif df['RFM_Score'] in ['111', '112', '121', '131', '141', '151']:
  94.         return 'Hibernating'
  95.     else:
  96.         return 'Others'
  98. rfm['Segment'] = rfm.apply(segment_customer, axis=1)
  100. print(rfm.head())
  102. # 可视化客户细分
  103. segment_counts = rfm['Segment'].value_counts()
  105. plt.figure(figsize=(12, 6))
  106. segment_counts.plot(kind='bar')
  107. plt.title('Customer Segments')
  108. plt.xlabel('Segment')
  109. plt.ylabel('Count')
  110. plt.xticks(rotation=45)
  111. plt.grid(True)
  112. plt.show()
  114. # 产品类别分析
  115. category_sales = df.groupby('ProductCategory')['Amount'].sum().reset_index()
  117. plt.figure(figsize=(10, 6))
  118. plt.bar(category_sales['ProductCategory'], category_sales['Amount'])
  119. plt.title('Sales by Product Category')
  120. plt.xlabel('Product Category')
  121. plt.ylabel('Sales Amount')
  122. plt.grid(True)
  123. plt.show()
  125. # 支付方式分析
  126. payment_sales = df.groupby('PaymentMethod')['Amount'].sum().reset_index()
  128. plt.figure(figsize=(10, 6))
  129. plt.bar(payment_sales['PaymentMethod'], payment_sales['Amount'])
  130. plt.title('Sales by Payment Method')
  131. plt.xlabel('Payment Method')
  132. plt.ylabel('Sales Amount')
  133. plt.grid(True)
  134. plt.show()
  136. # 时间趋势分析
  137. df['Month'] = df['Date'].dt.to_period('M')
  138. monthly_sales = df.groupby('Month')['Amount'].sum().reset_index()
  139. monthly_sales['Month'] = monthly_sales['Month'].dt.to_timestamp()
  141. plt.figure(figsize=(12, 6))
  142. plt.plot(monthly_sales['Month'], monthly_sales['Amount'])
  143. plt.title('Monthly Sales Trend')
  144. plt.xlabel('Month')
  145. plt.ylabel('Sales Amount')
  146. plt.grid(True)
  147. plt.show()
复制代码

性能优化

处理大型数据集时，性能优化非常重要。以下是一些提高Pandas操作效率的技巧。

使用适当的数据类型
  2. # 查看数据类型
  3. print(df.dtypes)
  5. # 转换为更节省内存的数据类型
  6. df['column_name'] = df['column_name'].astype('int32')  # 从int64转为int32
  7. df['column_name'] = df['column_name'].astype('float32')  # 从float64转为float32
  8. df['column_name'] = df['column_name'].astype('category')  # 对于具有少量唯一值的字符串列
  10. # 查看内存使用情况
  11. print(df.memory_usage())
复制代码

避免循环
  2. # 不好的方式：使用循环
  3. for i in range(len(df)):
  4.     df.loc[i, 'new_column'] = df.loc[i, 'column1'] + df.loc[i, 'column2']
  6. # 好的方式：向量化操作
  7. df['new_column'] = df['column1'] + df['column2']
  9. # 使用apply函数
  10. df['new_column'] = df.apply(lambda row: row['column1'] + row['column2'], axis=1)
复制代码

使用内置方法
  2. # 不好的方式：使用Python内置函数
  3. df['new_column'] = [x.upper() for x in df['column_name']]
  5. # 好的方式：使用Pandas内置方法
  6. df['new_column'] = df['column_name'].str.upper()
复制代码

批量处理数据
  2. # 处理大型数据集时，可以使用chunksize参数分批读取
  3. chunk_size = 10000
  4. chunks = pd.read_csv('large_file.csv', chunksize=chunk_size)
  6. for chunk in chunks:
  7.     # 处理每个数据块
  8.     process(chunk)
复制代码

使用eval()和query()
  2. # 使用eval()进行高效计算
  3. df.eval('new_column = column1 + column2', inplace=True)
  5. # 使用query()进行高效筛选
  6. result = df.query('column1 > 10 and column2 < 20')
复制代码

使用并行处理
  2. from multiprocessing import Pool
  4. def process_chunk(chunk):
  5.     # 处理数据块的函数
  6.     return processed_chunk
  8. # 创建进程池
  9. pool = Pool(processes=4)
  11. # 分块处理数据
  12. chunks = np.array_split(df, 4)
  13. results = pool.map(process_chunk, chunks)
  15. # 合并结果
  16. final_result = pd.concat(results)
复制代码

使用Categorical数据类型
  2. # 对于具有少量唯一值的列，使用category类型可以节省内存并提高性能
  3. df['column_name'] = df['column_name'].astype('category')
  5. # 查看类别
  6. print(df['column_name'].cat.categories)
复制代码

使用索引优化
  2. # 设置索引可以提高查询速度
  3. df.set_index('column_name', inplace=True)
  5. # 使用索引进行查询
  6. result = df.loc['value']
  8. # 对于多列查询，可以设置多级索引
  9. df.set_index(['column1', 'column2'], inplace=True)
  10. result = df.loc[('value1', 'value2')]
复制代码

总结与展望

Pandas是Python数据分析的核心库，提供了丰富的数据结构和函数，使数据处理变得简单高效。本文深入浅出地介绍了Pandas库的核心功能，包括数据结构、数据导入导出、数据清洗、数据探索与预处理、数据分组与聚合、数据合并与重塑、时间序列分析、数据可视化等内容，并通过实际案例展示了Pandas在数据分析中的应用。

随着数据量的不断增长和数据分析需求的日益复杂，Pandas库也在不断发展和完善。未来，我们可以期待Pandas在以下方面的发展：

1. 性能优化：随着数据规模的扩大，Pandas将继续优化其核心算法，提高处理大数据集的效率。
2. 分布式计算：与Dask等分布式计算框架的集成，使Pandas能够处理超出内存限制的大数据集。
3. 更好的可视化：增强内置可视化功能，提供更多交互式图表选项。
4. 更丰富的数据类型支持：支持更多特殊数据类型，如地理空间数据、图形数据等。
5. 与机器学习的更紧密集成：提供更多与机器学习工作流无缝集成的功能。

性能优化：随着数据规模的扩大，Pandas将继续优化其核心算法，提高处理大数据集的效率。

分布式计算：与Dask等分布式计算框架的集成，使Pandas能够处理超出内存限制的大数据集。

更好的可视化：增强内置可视化功能，提供更多交互式图表选项。

更丰富的数据类型支持：支持更多特殊数据类型，如地理空间数据、图形数据等。

与机器学习的更紧密集成：提供更多与机器学习工作流无缝集成的功能。

通过掌握Pandas库的使用，数据分析师和科学家可以更高效地处理和分析数据，从数据中提取有价值的洞察，为决策提供支持。希望本文能够帮助读者轻松掌握Pandas数据处理技能，提升工作效率，解决实际问题。

随着数据分析领域的不断发展，持续学习和实践是提高数据分析能力的关键。建议读者在实际项目中应用Pandas，探索其更多功能，并关注其最新发展，以保持竞争力。
数据处理, 工作效率, 实例, 实战, 技能
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

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

本版积分规则

友情链接

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

加入Discord频道

加入QQ社群

加入QQ社群

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

Powered by Pixtech

© 2025-2026 Pixtech Team.