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

开启辅助访问 切换到宽版

站内搜索

搜索

活动公告

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

Matplotlib与Pandas集成应用实战指南利用Python两大神器轻松实现数据分析和可视化无缝对接

威震华夏关云长
SunJu_FaceMall

3万

主题

166

科技点

3万

积分

大区版主

碾压王

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

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

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

x
引言

在数据科学领域，Python已经成为最受欢迎的编程语言之一。而在Python的数据科学生态系统中，Matplotlib和Pandas无疑是两个最重要的库。Pandas提供了强大的数据处理和分析能力，而Matplotlib则是Python中最基础、最广泛使用的数据可视化库。将这两个库结合使用，可以实现从数据处理到可视化展示的无缝对接，大大提高数据分析的效率和效果。

本文将深入探讨如何将Matplotlib与Pandas进行有效集成，通过实战案例展示它们如何协同工作，帮助读者掌握利用这两大工具进行数据分析和可视化的技巧。

基础知识回顾

Pandas简介

Pandas是一个开源的数据分析和操作库，提供了高性能、易于使用的数据结构和数据分析工具。Pandas的核心数据结构是DataFrame，它是一个二维的、大小可变的、 potentially heterogeneous的表格型数据结构，带有标记的轴（行和列）。
  2. import pandas as pd
  4. # 创建一个简单的DataFrame
  5. data = {'Name': ['John', 'Anna', 'Peter', 'Linda'],
  6.         'Age': [28, 34, 29, 32],
  7.         'City': ['New York', 'Paris', 'Berlin', 'London']}
  8. df = pd.DataFrame(data)
  9. print(df)
复制代码

Matplotlib简介

Matplotlib是Python中最基础的可视化库，它提供了一个类似于MATLAB的绘图接口。使用Matplotlib，可以创建各种静态、动态和交互式的可视化图表。
  2. import matplotlib.pyplot as plt
  4. # 创建一个简单的折线图
  5. x = [1, 2, 3, 4]
  6. y = [10, 20, 25, 30]
  7. plt.plot(x, y)
  8. plt.xlabel('X轴')
  9. plt.ylabel('Y轴')
  10. plt.title('简单折线图')
  11. plt.show()
复制代码

集成方法

基本集成方式

Matplotlib与Pandas的集成非常简单，因为Pandas内置了对Matplotlib的支持。最基本的方式是使用DataFrame或Series的plot()方法，这实际上是调用了Matplotlib的绘图函数。
  2. import pandas as pd
  3. import matplotlib.pyplot as plt
  5. # 创建一个DataFrame
  6. data = {'Year': [2010, 2011, 2012, 2013, 2014],
  7.         'Sales': [100, 150, 200, 250, 300]}
  8. df = pd.DataFrame(data)
  10. # 使用Pandas的plot方法绘图
  11. df.plot(x='Year', y='Sales', kind='line')
  12. plt.title('年度销售额')
  13. plt.ylabel('销售额（万元）')
  14. plt.show()
复制代码

使用Matplotlib直接绘制Pandas数据

除了使用Pandas内置的plot方法外，我们还可以直接使用Matplotlib来绘制Pandas数据。这种方式提供了更多的自定义选项。
  2. import pandas as pd
  3. import matplotlib.pyplot as plt
  5. # 创建一个DataFrame
  6. data = {'Year': [2010, 2011, 2012, 2013, 2014],
  7.         'Sales': [100, 150, 200, 250, 300],
  8.         'Expenses': [80, 120, 150, 180, 200]}
  9. df = pd.DataFrame(data)
  11. # 使用Matplotlib直接绘制
  12. plt.figure(figsize=(10, 6))
  13. plt.plot(df['Year'], df['Sales'], label='销售额', marker='o')
  14. plt.plot(df['Year'], df['Expenses'], label='支出', marker='s')
  15. plt.xlabel('年份')
  16. plt.ylabel('金额（万元）')
  17. plt.title('年度销售额与支出')
  18. plt.legend()
  19. plt.grid(True)
  20. plt.show()
复制代码

使用Pandas的内置绘图功能

Pandas提供了多种内置的绘图类型，可以通过kind参数指定：

• ‘line’：折线图（默认）
• ‘bar’：垂直条形图
• ‘barh’：水平条形图
• ‘hist’：直方图
• ‘box’：箱线图
• ‘kde’：核密度估计图
• ‘density’：同’kde’
• ‘area’：面积图
• ‘pie’：饼图
• ‘scatter’：散点图
• ‘hexbin’：六边形分箱图
  2. import pandas as pd
  3. import matplotlib.pyplot as plt
  5. # 创建一个DataFrame
  6. data = {'Product': ['A', 'B', 'C', 'D'],
  7.         'Sales': [100, 150, 200, 250],
  8.         'Profit': [30, 45, 60, 75]}
  9. df = pd.DataFrame(data)
  11. # 创建一个2x2的子图布局
  12. fig, axes = plt.subplots(2, 2, figsize=(12, 10))
  14. # 绘制条形图
  15. df.plot(x='Product', y='Sales', kind='bar', ax=axes[0, 0])
  16. axes[0, 0].set_title('产品销售额')
  18. # 绘制水平条形图
  19. df.plot(x='Product', y='Sales', kind='barh', ax=axes[0, 1])
  20. axes[0, 1].set_title('产品销售额（水平）')
  22. # 绘制饼图
  23. df.plot(y='Sales', kind='pie', labels=df['Product'], autopct='%1.1f%%', ax=axes[1, 0])
  24. axes[1, 0].set_title('销售额占比')
  25. axes[1, 0].legend().set_visible(False)
  27. # 绘制散点图
  28. df.plot(x='Sales', y='Profit', kind='scatter', ax=axes[1, 1])
  29. axes[1, 1].set_title('销售额与利润关系')
  31. plt.tight_layout()
  32. plt.show()
复制代码

实战案例

案例1：销售数据分析与可视化

假设我们有一份销售数据，包含日期、产品类别、销售额等信息。我们将使用Pandas进行数据处理，然后使用Matplotlib进行可视化。
  2. import pandas as pd
  3. import matplotlib.pyplot as plt
  4. import numpy as np
  5. from datetime import datetime, timedelta
  7. # 创建模拟数据
  8. np.random.seed(42)
  9. date_range = pd.date_range(start='2022-01-01', end='2022-12-31', freq='D')
  10. categories = ['电子产品', '服装', '食品', '家居', '图书']
  11. n = len(date_range)
  13. data = {
  14.     'Date': np.random.choice(date_range, n),
  15.     'Category': np.random.choice(categories, n),
  16.     'Sales': np.random.randint(100, 1000, n),
  17.     'Profit': np.random.randint(10, 100, n)
  18. }
  20. df = pd.DataFrame(data)
  22. # 按月份和类别汇总销售额
  23. df['Month'] = df['Date'].dt.to_period('M')
  24. monthly_sales = df.groupby(['Month', 'Category'])['Sales'].sum().unstack()
  26. # 绘制月度销售额趋势
  27. plt.figure(figsize=(12, 6))
  28. monthly_sales.plot(kind='line', marker='o')
  29. plt.title('2022年各类产品月度销售额趋势')
  30. plt.xlabel('月份')
  31. plt.ylabel('销售额（元）')
  32. plt.grid(True)
  33. plt.legend(title='产品类别')
  34. plt.tight_layout()
  35. plt.show()
  37. # 计算各类别销售额占比
  38. category_sales = df.groupby('Category')['Sales'].sum()
  39. plt.figure(figsize=(8, 8))
  40. category_sales.plot(kind='pie', autopct='%1.1f%%', startangle=90)
  41. plt.title('2022年各类产品销售额占比')
  42. plt.ylabel('')  # 移除y标签
  43. plt.tight_layout()
  44. plt.show()
  46. # 分析销售额与利润的关系
  47. plt.figure(figsize=(10, 6))
  48. plt.scatter(df['Sales'], df['Profit'], alpha=0.5)
  49. plt.title('销售额与利润关系')
  50. plt.xlabel('销售额（元）')
  51. plt.ylabel('利润（元）')
  52. plt.grid(True)
  53. plt.tight_layout()
  54. plt.show()
复制代码

案例2：股票数据分析与可视化

在这个案例中，我们将分析股票数据，包括价格走势、交易量、移动平均线等。
  2. import pandas as pd
  3. import matplotlib.pyplot as plt
  4. import numpy as np
  5. from datetime import datetime, timedelta
  7. # 创建模拟股票数据
  8. np.random.seed(42)
  9. date_range = pd.date_range(start='2022-01-01', end='2022-12-31', freq='D')
  10. n = len(date_range)
  12. # 生成随机价格走势
  13. initial_price = 100
  14. price_changes = np.random.normal(0, 1, n)
  15. prices = [initial_price]
  16. for change in price_changes:
  17.     prices.append(prices[-1] * (1 + change/100))
  18. prices = prices[1:]  # 移除初始价格
  20. # 生成交易量
  21. volumes = np.random.randint(100000, 500000, n)
  23. # 创建DataFrame
  24. stock_data = pd.DataFrame({
  25.     'Date': date_range,
  26.     'Open': prices * np.random.uniform(0.98, 1.02, n),
  27.     'High': prices * np.random.uniform(1.01, 1.05, n),
  28.     'Low': prices * np.random.uniform(0.95, 0.99, n),
  29.     'Close': prices,
  30.     'Volume': volumes
  31. })
  33. # 计算移动平均线
  34. stock_data['MA5'] = stock_data['Close'].rolling(window=5).mean()
  35. stock_data['MA20'] = stock_data['Close'].rolling(window=20).mean()
  36. stock_data['MA60'] = stock_data['Close'].rolling(window=60).mean()
  38. # 绘制价格走势和移动平均线
  39. plt.figure(figsize=(12, 8))
  40. plt.plot(stock_data['Date'], stock_data['Close'], label='收盘价', alpha=0.7)
  41. plt.plot(stock_data['Date'], stock_data['MA5'], label='5日均线', alpha=0.7)
  42. plt.plot(stock_data['Date'], stock_data['MA20'], label='20日均线', alpha=0.7)
  43. plt.plot(stock_data['Date'], stock_data['MA60'], label='60日均线', alpha=0.7)
  44. plt.title('股票价格走势与移动平均线')
  45. plt.xlabel('日期')
  46. plt.ylabel('价格（元）')
  47. plt.legend()
  48. plt.grid(True)
  49. plt.tight_layout()
  50. plt.show()
  52. # 绘制交易量
  53. plt.figure(figsize=(12, 6))
  54. plt.bar(stock_data['Date'], stock_data['Volume'], color=np.where(stock_data['Close'] >= stock_data['Open'], 'g', 'r'))
  55. plt.title('股票交易量')
  56. plt.xlabel('日期')
  57. plt.ylabel('交易量')
  58. plt.grid(True)
  59. plt.tight_layout()
  60. plt.show()
  62. # 绘制K线图（简化版）
  63. fig, ax = plt.subplots(figsize=(12, 8))
  65. # 定义上涨和下跌的颜色
  66. up = stock_data['Close'] >= stock_data['Open']
  67. down = ~up
  69. # 绘制K线
  70. for idx, row in stock_data.iterrows():
  71.     if up[idx]:
  72.         color = 'red'
  73.         lower = row['Open']
  74.         height = row['Close'] - row['Open']
  75.     else:
  76.         color = 'green'
  77.         lower = row['Close']
  78.         height = row['Open'] - row['Close']
  79.    
  80.     # 绘制影线
  81.     ax.plot([row['Date'], row['Date']], [row['Low'], row['High']], color=color)
  82.    
  83.     # 绘制实体
  84.     ax.bar(row['Date'], height, bottom=lower, width=0.6, color=color)
  86. plt.title('股票K线图')
  87. plt.xlabel('日期')
  88. plt.ylabel('价格（元）')
  89. plt.grid(True)
  90. plt.tight_layout()
  91. plt.show()
复制代码

案例3：人口统计分析与可视化

在这个案例中，我们将分析人口统计数据，包括年龄分布、性别比例、教育水平等。
  2. import pandas as pd
  3. import matplotlib.pyplot as plt
  4. import numpy as np
  6. # 创建模拟人口数据
  7. np.random.seed(42)
  8. n = 1000
  10. data = {
  11.     'Age': np.random.randint(18, 80, n),
  12.     'Gender': np.random.choice(['男', '女'], n),
  13.     'Education': np.random.choice(['小学', '初中', '高中', '大专', '本科', '硕士', '博士'], n, p=[0.05, 0.1, 0.2, 0.2, 0.3, 0.1, 0.05]),
  14.     'Income': np.random.randint(2000, 20000, n),
  15.     'City': np.random.choice(['北京', '上海', '广州', '深圳', '杭州', '成都'], n)
  16. }
  18. df = pd.DataFrame(data)
  20. # 年龄分布分析
  21. plt.figure(figsize=(10, 6))
  22. plt.hist(df['Age'], bins=15, edgecolor='black', alpha=0.7)
  23. plt.title('人口年龄分布')
  24. plt.xlabel('年龄')
  25. plt.ylabel('人数')
  26. plt.grid(True, alpha=0.3)
  27. plt.tight_layout()
  28. plt.show()
  30. # 性别比例
  31. gender_counts = df['Gender'].value_counts()
  32. plt.figure(figsize=(8, 8))
  33. plt.pie(gender_counts, labels=gender_counts.index, autopct='%1.1f%%', startangle=90)
  34. plt.title('性别比例')
  35. plt.tight_layout()
  36. plt.show()
  38. # 教育水平分布
  39. education_counts = df['Education'].value_counts().sort_index()
  40. plt.figure(figsize=(10, 6))
  41. education_counts.plot(kind='bar', color='skyblue')
  42. plt.title('教育水平分布')
  43. plt.xlabel('教育水平')
  44. plt.ylabel('人数')
  45. plt.grid(True, alpha=0.3)
  46. plt.tight_layout()
  47. plt.show()
  49. # 城市与收入关系
  50. city_income = df.groupby('City')['Income'].mean().sort_values(ascending=False)
  51. plt.figure(figsize=(10, 6))
  52. city_income.plot(kind='bar', color='green')
  53. plt.title('各城市平均收入')
  54. plt.xlabel('城市')
  55. plt.ylabel('平均收入（元）')
  56. plt.grid(True, alpha=0.3)
  57. plt.tight_layout()
  58. plt.show()
  60. # 年龄与收入关系（按性别分组）
  61. plt.figure(figsize=(10, 6))
  62. for gender in ['男', '女']:
  63.     subset = df[df['Gender'] == gender]
  64.     plt.scatter(subset['Age'], subset['Income'], alpha=0.5, label=gender)
  65. plt.title('年龄与收入关系（按性别分组）')
  66. plt.xlabel('年龄')
  67. plt.ylabel('收入（元）')
  68. plt.legend()
  69. plt.grid(True, alpha=0.3)
  70. plt.tight_layout()
  71. plt.show()
  73. # 教育水平与收入关系
  74. education_income = df.groupby('Education')['Income'].mean().sort_values()
  75. plt.figure(figsize=(10, 6))
  76. education_income.plot(kind='barh', color='purple')
  77. plt.title('教育水平与平均收入关系')
  78. plt.xlabel('平均收入（元）')
  79. plt.ylabel('教育水平')
  80. plt.grid(True, alpha=0.3)
  81. plt.tight_layout()
  82. plt.show()
复制代码

高级技巧

自定义图表样式

Matplotlib允许我们自定义图表的各种样式，包括颜色、线型、标记、字体等。
  2. import pandas as pd
  3. import matplotlib.pyplot as plt
  4. import numpy as np
  6. # 创建模拟数据
  7. np.random.seed(42)
  8. years = np.arange(2010, 2021)
  9. sales_A = np.random.randint(100, 300, len(years))
  10. sales_B = np.random.randint(150, 350, len(years))
  12. df = pd.DataFrame({
  13.     'Year': years,
  14.     'Product_A': sales_A,
  15.     'Product_B': sales_B
  16. })
  18. # 设置图表样式
  19. plt.style.use('seaborn')  # 使用seaborn风格
  20. plt.figure(figsize=(12, 6))
  22. # 绘制图表并自定义样式
  23. plt.plot(df['Year'], df['Product_A'],
  24.          color='#1f77b4',  # 自定义颜色
  25.          linestyle='--',   # 虚线
  26.          marker='o',       # 圆形标记
  27.          markersize=8,     # 标记大小
  28.          markerfacecolor='white',  # 标记面颜色
  29.          markeredgewidth=2,        # 标记边宽度
  30.          label='产品A')
  32. plt.plot(df['Year'], df['Product_B'],
  33.          color='#ff7f0e',  # 自定义颜色
  34.          linestyle='-',    # 实线
  35.          marker='s',       # 方形标记
  36.          markersize=8,     # 标记大小
  37.          markerfacecolor='white',  # 标记面颜色
  38.          markeredgewidth=2,        # 标记边宽度
  39.          label='产品B')
  41. # 自定义标题和标签
  42. plt.title('产品销售趋势对比', fontsize=16, fontweight='bold', pad=20)
  43. plt.xlabel('年份', fontsize=12, labelpad=10)
  44. plt.ylabel('销售额（万元）', fontsize=12, labelpad=10)
  46. # 自定义刻度
  47. plt.xticks(df['Year'], rotation=45)  # 旋转x轴标签
  48. plt.yticks(np.arange(0, max(max(sales_A), max(sales_B)) + 50, 50))
  50. # 自定义网格
  51. plt.grid(True, linestyle=':', alpha=0.6)  # 点线网格，半透明
  53. # 自定义图例
  54. plt.legend(fontsize=12, frameon=True, fancybox=True, framealpha=0.8,
  55.            loc='upper left', bbox_to_anchor=(1, 1))  # 图例放在图表外
  57. # 调整边距
  58. plt.tight_layout()
  59. plt.show()
复制代码

多子图布局

Matplotlib提供了多种方式来创建多子图布局，包括subplots()、subplot2grid()和GridSpec等。
  2. import pandas as pd
  3. import matplotlib.pyplot as plt
  4. import numpy as np
  5. from matplotlib.gridspec import GridSpec
  7. # 创建模拟数据
  8. np.random.seed(42)
  9. categories = ['电子产品', '服装', '食品', '家居', '图书']
  10. n = len(categories)
  12. data = {
  13.     'Category': categories,
  14.     'Sales': np.random.randint(100, 500, n),
  15.     'Profit': np.random.randint(20, 100, n),
  16.     'Growth': np.random.uniform(-5, 15, n)
  17. }
  19. df = pd.DataFrame(data)
  21. # 使用GridSpec创建复杂布局
  22. fig = plt.figure(figsize=(14, 10))
  23. gs = GridSpec(3, 2, figure=fig)
  25. # 第一个子图：销售额条形图
  26. ax1 = fig.add_subplot(gs[0, 0])
  27. bars = ax1.bar(df['Category'], df['Sales'], color='skyblue')
  28. ax1.set_title('产品销售额', fontsize=14, fontweight='bold')
  29. ax1.set_ylabel('销售额（万元）')
  30. ax1.grid(True, alpha=0.3)
  32. # 在条形上添加数值标签
  33. for bar in bars:
  34.     height = bar.get_height()
  35.     ax1.text(bar.get_x() + bar.get_width()/2., height,
  36.              f'{height}',
  37.              ha='center', va='bottom')
  39. # 第二个子图：利润条形图
  40. ax2 = fig.add_subplot(gs[0, 1])
  41. bars = ax2.bar(df['Category'], df['Profit'], color='lightgreen')
  42. ax2.set_title('产品利润', fontsize=14, fontweight='bold')
  43. ax2.set_ylabel('利润（万元）')
  44. ax2.grid(True, alpha=0.3)
  46. # 在条形上添加数值标签
  47. for bar in bars:
  48.     height = bar.get_height()
  49.     ax2.text(bar.get_x() + bar.get_width()/2., height,
  50.              f'{height}',
  51.              ha='center', va='bottom')
  53. # 第三个子图：增长率折线图
  54. ax3 = fig.add_subplot(gs[1, :])
  55. ax3.plot(df['Category'], df['Growth'], marker='o', linestyle='-', color='red', markersize=8)
  56. ax3.set_title('产品增长率', fontsize=14, fontweight='bold')
  57. ax3.set_ylabel('增长率（%）')
  58. ax3.grid(True, alpha=0.3)
  60. # 添加零线
  61. ax3.axhline(y=0, color='black', linestyle='-', alpha=0.3)
  63. # 在数据点上添加数值标签
  64. for i, v in enumerate(df['Growth']):
  65.     ax3.text(i, v + (0.5 if v >= 0 else -1.5), f'{v:.1f}%',
  66.              ha='center', va='bottom' if v >= 0 else 'top')
  68. # 第四个子图：销售额与利润散点图
  69. ax4 = fig.add_subplot(gs[2, :])
  70. scatter = ax4.scatter(df['Sales'], df['Profit'], s=100, c=df['Growth'],
  71.                      cmap='coolwarm', alpha=0.7, edgecolors='black')
  72. ax4.set_title('销售额与利润关系（颜色表示增长率）', fontsize=14, fontweight='bold')
  73. ax4.set_xlabel('销售额（万元）')
  74. ax4.set_ylabel('利润（万元）')
  75. ax4.grid(True, alpha=0.3)
  77. # 添加颜色条
  78. cbar = plt.colorbar(scatter, ax=ax4)
  79. cbar.set_label('增长率（%）')
  81. # 为每个点添加产品标签
  82. for i, row in df.iterrows():
  83.     ax4.text(row['Sales'], row['Profit'], row['Category'],
  84.              ha='center', va='bottom', fontsize=10)
  86. # 调整子图间距
  87. plt.tight_layout()
  88. plt.show()
复制代码

交互式可视化

Matplotlib虽然主要用于静态图表，但也支持一些基本的交互功能。
  2. import pandas as pd
  3. import matplotlib.pyplot as plt
  4. import numpy as np
  5. from matplotlib.widgets import Slider, Button
  7. # 创建模拟数据
  8. np.random.seed(42)
  9. years = np.arange(2000, 2021)
  10. categories = ['产品A', '产品B', '产品C', '产品D', '产品E']
  11. n = len(years)
  13. # 为每个产品创建随机销售额数据
  14. data = {'Year': years}
  15. for category in categories:
  16.     # 每个产品有不同的基础销售额和增长趋势
  17.     base_sales = np.random.randint(100, 300)
  18.     growth_rate = np.random.uniform(0.01, 0.05)
  19.     sales = [base_sales * (1 + growth_rate) ** i for i in range(n)]
  20.     # 添加一些随机波动
  21.     sales = sales * np.random.uniform(0.9, 1.1, n)
  22.     data[category] = sales
  24. df = pd.DataFrame(data)
  26. # 创建图表和轴
  27. fig, ax = plt.subplots(figsize=(12, 6))
  28. plt.subplots_adjust(bottom=0.25)  # 为滑块留出空间
  30. # 初始绘制所有产品
  31. lines = []
  32. for category in categories:
  33.     line, = ax.plot(df['Year'], df[category], label=category, marker='o', markersize=4)
  34.     lines.append(line)
  36. # 设置图表属性
  37. ax.set_title('产品销售趋势（可交互）', fontsize=16, fontweight='bold')
  38. ax.set_xlabel('年份')
  39. ax.set_ylabel('销售额（万元）')
  40. ax.grid(True, alpha=0.3)
  41. ax.legend(loc='upper left')
  43. # 添加滑块用于调整年份范围
  44. axcolor = 'lightgoldenrodyellow'
  45. ax_year = plt.axes([0.25, 0.1, 0.65, 0.03], facecolor=axcolor)
  47. year_slider = Slider(
  48.     ax=ax_year,
  49.     label='显示年份范围',
  50.     valmin=0,
  51.     valmax=len(years)-1,
  52.     valinit=len(years)-1,
  53.     valstep=1
  54. )
  56. # 定义滑块更新函数
  57. def update(val):
  58.     year_idx = int(year_slider.val)
  59.     ax.set_xlim(years[0], years[year_idx])
  60.     fig.canvas.draw_idle()
  62. year_slider.on_changed(update)
  64. # 添加按钮用于切换显示/隐藏产品线
  65. ax_button = []
  66. buttons = []
  68. for i, category in enumerate(categories):
  69.     # 为每个按钮创建轴
  70.     ax_btn = plt.axes([0.1 + i*0.15, 0.01, 0.1, 0.04])
  71.     ax_button.append(ax_btn)
  72.    
  73.     # 创建按钮
  74.     btn = Button(ax_btn, category, color=axcolor, hovercolor='0.975')
  75.     buttons.append(btn)
  76.    
  77.     # 定义按钮点击函数
  78.     def make_click_func(line, idx):
  79.         def click(event):
  80.             line.set_visible(not line.get_visible())
  81.             fig.canvas.draw_idle()
  82.         return click
  83.    
  84.     btn.on_clicked(make_click_func(lines[i], i))
  86. plt.show()
复制代码

动画可视化

Matplotlib还支持创建动画，可以用来展示数据随时间的变化。
  2. import pandas as pd
  3. import matplotlib.pyplot as plt
  4. import numpy as np
  5. from matplotlib.animation import FuncAnimation
  6. from matplotlib.colors import Normalize
  7. from matplotlib.cm import ScalarMappable
  9. # 创建模拟数据
  10. np.random.seed(42)
  11. years = np.arange(2000, 2021)
  12. categories = ['电子产品', '服装', '食品', '家居', '图书']
  13. n = len(years)
  15. # 为每个类别创建随机销售额数据
  16. data = {'Year': years}
  17. for category in categories:
  18.     # 每个类别有不同的基础销售额和增长趋势
  19.     base_sales = np.random.randint(100, 300)
  20.     growth_rate = np.random.uniform(0.01, 0.05)
  21.     sales = [base_sales * (1 + growth_rate) ** i for i in range(n)]
  22.     # 添加一些随机波动
  23.     sales = sales * np.random.uniform(0.9, 1.1, n)
  24.     data[category] = sales
  26. df = pd.DataFrame(data)
  28. # 创建图表和轴
  29. fig, ax = plt.subplots(figsize=(12, 6))
  31. # 初始化条形图
  32. bars = ax.bar(categories, [0] * len(categories), color='skyblue')
  34. # 设置图表属性
  35. ax.set_title('产品销售额变化（2000-2020）', fontsize=16, fontweight='bold')
  36. ax.set_xlabel('产品类别')
  37. ax.set_ylabel('销售额（万元）')
  38. ax.set_ylim(0, df[categories].max().max() * 1.1)  # 设置y轴范围
  39. ax.grid(True, alpha=0.3)
  41. # 添加年份文本
  42. year_text = ax.text(0.02, 0.95, '', transform=ax.transAxes, fontsize=12,
  43.                    bbox=dict(facecolor='white', alpha=0.7))
  45. # 创建颜色映射
  46. norm = Normalize(vmin=0, vmax=len(years)-1)
  47. cmap = plt.cm.viridis
  48. sm = ScalarMappable(norm=norm, cmap=cmap)
  49. sm.set_array([])
  51. # 添加颜色条
  52. cbar = plt.colorbar(sm, ax=ax, ticks=np.arange(0, len(years), 5))
  53. cbar.set_ticklabels(years[::5])
  54. cbar.set_label('年份')
  56. # 定义动画更新函数
  57. def update(frame):
  58.     # 更新条形图高度
  59.     for bar, category in zip(bars, categories):
  60.         bar.set_height(df[category].iloc[frame])
  61.         # 根据年份设置颜色
  62.         bar.set_color(cmap(norm(frame)))
  63.    
  64.     # 更新年份文本
  65.     year_text.set_text(f'年份: {years[frame]}')
  66.    
  67.     return bars + [year_text]
  69. # 创建动画
  70. ani = FuncAnimation(fig, update, frames=len(years), interval=200, blit=True)
  72. plt.tight_layout()
  73. plt.show()
  75. # 如果需要保存动画为GIF，可以使用以下代码
  76. # ani.save('sales_animation.gif', writer='pillow', fps=5)
复制代码

最佳实践

数据准备与清洗

在使用Matplotlib和Pandas进行数据可视化之前，良好的数据准备和清洗是非常重要的。
  2. import pandas as pd
  3. import numpy as np
  5. # 创建包含缺失值和异常值的模拟数据
  6. np.random.seed(42)
  7. dates = pd.date_range(start='2022-01-01', end='2022-12-31', freq='D')
  8. n = len(dates)
  10. # 创建基础数据
  11. data = {
  12.     'Date': dates,
  13.     'Product_A': np.random.normal(100, 20, n),
  14.     'Product_B': np.random.normal(150, 30, n),
  15.     'Product_C': np.random.normal(200, 40, n)
  16. }
  18. df = pd.DataFrame(data)
  20. # 添加一些缺失值
  21. for _ in range(20):
  22.     df.loc[np.random.randint(0, n), np.random.choice(['Product_A', 'Product_B', 'Product_C'])] = np.nan
  24. # 添加一些异常值
  25. for _ in range(5):
  26.     df.loc[np.random.randint(0, n), np.random.choice(['Product_A', 'Product_B', 'Product_C'])] *= 5
  28. # 检查缺失值
  29. print("缺失值统计:")
  30. print(df.isnull().sum())
  32. # 处理缺失值 - 使用前向填充
  33. df_filled = df.fillna(method='ffill')
  35. # 如果还有缺失值（比如开头的数据），使用后向填充
  36. df_filled = df_filled.fillna(method='bfill')
  38. # 检查异常值 - 使用Z-score方法
  39. from scipy import stats
  41. z_scores = stats.zscore(df_filled[['Product_A', 'Product_B', 'Product_C']])
  42. abs_z_scores = np.abs(z_scores)
  43. filtered_entries = (abs_z_scores < 3).all(axis=1)
  44. df_cleaned = df_filled[filtered_entries]
  46. print(f"\n原始数据行数: {len(df)}")
  47. print(f"清洗后数据行数: {len(df_cleaned)}")
  48. print(f"移除的异常值行数: {len(df) - len(df_cleaned)}")
  50. # 添加一些有用的衍生列
  51. df_cleaned['Month'] = df_cleaned['Date'].dt.month
  52. df_cleaned['DayOfWeek'] = df_cleaned['Date'].dt.dayofweek
  53. df_cleaned['Total_Sales'] = df_cleaned['Product_A'] + df_cleaned['Product_B'] + df_cleaned['Product_C']
  55. # 按月份汇总数据
  56. monthly_data = df_cleaned.groupby('Month').agg({
  57.     'Product_A': 'mean',
  58.     'Product_B': 'mean',
  59.     'Product_C': 'mean',
  60.     'Total_Sales': 'mean'
  61. }).reset_index()
  63. print("\n月度平均销售额:")
  64. print(monthly_data)
复制代码

选择合适的图表类型

不同的数据类型和分析目的需要不同的图表类型。以下是一些常见的数据类型和适合的图表类型：

1. 时间序列数据：折线图、面积图
2. 分类数据比较：条形图、饼图
3. 分布数据：直方图、箱线图、密度图
4. 关系数据：散点图、气泡图
5. 组成数据：堆叠条形图、饼图
  2. import pandas as pd
  3. import matplotlib.pyplot as plt
  4. import numpy as np
  6. # 创建模拟数据
  7. np.random.seed(42)
  8. n = 1000
  10. data = {
  11.     'Age': np.random.randint(18, 80, n),
  12.     'Income': np.random.randint(2000, 20000, n),
  13.     'Spending': np.random.randint(1000, 15000, n),
  14.     'Category': np.random.choice(['A', 'B', 'C', 'D'], n),
  15.     'Satisfaction': np.random.randint(1, 6, n)
  16. }
  18. df = pd.DataFrame(data)
  20. # 1. 时间序列数据 - 折线图
  21. # 创建时间序列数据
  22. dates = pd.date_range(start='2022-01-01', end='2022-12-31', freq='D')
  23. ts_data = pd.DataFrame({
  24.     'Date': dates,
  25.     'Value': np.cumsum(np.random.normal(0, 1, len(dates))) + 100
  26. })
  28. plt.figure(figsize=(12, 6))
  29. plt.plot(ts_data['Date'], ts_data['Value'])
  30. plt.title('时间序列数据 - 折线图')
  31. plt.xlabel('日期')
  32. plt.ylabel('值')
  33. plt.grid(True, alpha=0.3)
  34. plt.tight_layout()
  35. plt.show()
  37. # 2. 分类数据比较 - 条形图
  38. category_counts = df['Category'].value_counts()
  39. plt.figure(figsize=(8, 6))
  40. category_counts.plot(kind='bar')
  41. plt.title('分类数据 - 条形图')
  42. plt.xlabel('类别')
  43. plt.ylabel('计数')
  44. plt.grid(True, alpha=0.3)
  45. plt.tight_layout()
  46. plt.show()
  48. # 3. 分布数据 - 直方图和箱线图
  49. fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
  51. # 直方图
  52. ax1.hist(df['Age'], bins=15, edgecolor='black', alpha=0.7)
  53. ax1.set_title('年龄分布 - 直方图')
  54. ax1.set_xlabel('年龄')
  55. ax1.set_ylabel('频数')
  56. ax1.grid(True, alpha=0.3)
  58. # 箱线图
  59. ax2.boxplot([df[df['Category'] == cat]['Income'] for cat in ['A', 'B', 'C', 'D']],
  60.             labels=['A', 'B', 'C', 'D'])
  61. ax2.set_title('各类别收入分布 - 箱线图')
  62. ax2.set_xlabel('类别')
  63. ax2.set_ylabel('收入')
  64. ax2.grid(True, alpha=0.3)
  66. plt.tight_layout()
  67. plt.show()
  69. # 4. 关系数据 - 散点图
  70. plt.figure(figsize=(8, 6))
  71. plt.scatter(df['Age'], df['Income'], alpha=0.5)
  72. plt.title('年龄与收入关系 - 散点图')
  73. plt.xlabel('年龄')
  74. plt.ylabel('收入')
  75. plt.grid(True, alpha=0.3)
  76. plt.tight_layout()
  77. plt.show()
  79. # 5. 组成数据 - 堆叠条形图
  80. # 创建组成数据
  81. composition_data = pd.DataFrame({
  82.     'Quarter': ['Q1', 'Q2', 'Q3', 'Q4'],
  83.     'Product_A': np.random.randint(100, 200, 4),
  84.     'Product_B': np.random.randint(150, 250, 4),
  85.     'Product_C': np.random.randint(50, 150, 4)
  86. })
  88. # 设置Quarter为索引
  89. composition_data.set_index('Quarter', inplace=True)
  91. plt.figure(figsize=(10, 6))
  92. composition_data.plot(kind='bar', stacked=True)
  93. plt.title('季度产品组成 - 堆叠条形图')
  94. plt.xlabel('季度')
  95. plt.ylabel('销售额')
  96. plt.legend(title='产品')
  97. plt.grid(True, alpha=0.3)
  98. plt.tight_layout()
  99. plt.show()
复制代码

图表美化与标注

良好的图表美化和标注可以使数据可视化更加清晰、专业。
  2. import pandas as pd
  3. import matplotlib.pyplot as plt
  4. import numpy as np
  5. from matplotlib.ticker import FuncFormatter
  7. # 创建模拟数据
  8. np.random.seed(42)
  9. years = np.arange(2015, 2023)
  10. categories = ['产品A', '产品B', '产品C', '产品D']
  11. n = len(years)
  13. # 创建数据
  14. data = {'Year': years}
  15. for category in categories:
  16.     base_sales = np.random.randint(100, 300)
  17.     growth_rate = np.random.uniform(0.05, 0.15)
  18.     sales = [base_sales * (1 + growth_rate) ** i for i in range(n)]
  19.     data[category] = sales
  21. df = pd.DataFrame(data)
  23. # 设置图表样式
  24. plt.style.use('seaborn')
  25. fig, ax = plt.subplots(figsize=(12, 8))
  27. # 绘制折线图
  28. for category in categories:
  29.     ax.plot(df['Year'], df[category], marker='o', markersize=8,
  30.             linewidth=2, label=category)
  32. # 设置标题和标签
  33. ax.set_title('产品销售趋势（2015-2022）', fontsize=16, fontweight='bold', pad=20)
  34. ax.set_xlabel('年份', fontsize=12, labelpad=10)
  35. ax.set_ylabel('销售额（万元）', fontsize=12, labelpad=10)
  37. # 设置刻度
  38. ax.set_xticks(df['Year'])
  39. ax.tick_params(axis='both', which='major', labelsize=10)
  41. # 格式化y轴刻度
  42. def millions_formatter(x, pos):
  43.     return f'{x/100:.1f}百'
  45. ax.yaxis.set_major_formatter(FuncFormatter(millions_formatter))
  47. # 添加网格
  48. ax.grid(True, linestyle='--', alpha=0.6)
  50. # 添加图例
  51. ax.legend(fontsize=12, frameon=True, fancybox=True, framealpha=0.8,
  52.           loc='upper left', bbox_to_anchor=(1, 1))
  54. # 添加数据标签
  55. for category in categories:
  56.     for i, value in enumerate(df[category]):
  57.         ax.annotate(f'{value:.0f}',
  58.                    xy=(df['Year'][i], value),
  59.                    xytext=(0, 5),  # 5 points vertical offset
  60.                    textcoords='offset points',
  61.                    ha='center', va='bottom',
  62.                    fontsize=9,
  63.                    bbox=dict(boxstyle='round,pad=0.3', fc='white', alpha=0.7))
  65. # 添加注释
  66. max_value = df[categories].max().max()
  67. max_year = df['Year'][df[categories].values.argmax() // len(categories)]
  68. max_category = categories[df[categories].values.argmax() % len(categories)]
  70. ax.annotate(f'最高销售额: {max_value:.0f}万元\n{max_year}年 {max_category}',
  71.             xy=(max_year, max_value),
  72.             xytext=(max_year-1, max_value-500),
  73.             arrowprops=dict(facecolor='black', shrink=0.05, width=1, headwidth=8),
  74.             bbox=dict(boxstyle='round,pad=0.5', fc='yellow', alpha=0.7),
  75.             fontsize=10, ha='center')
  77. # 添加平均线
  78. avg_values = df[categories].mean(axis=1)
  79. ax.plot(df['Year'], avg_values, linestyle='--', color='gray', alpha=0.7, label='平均值')
  80. ax.legend(fontsize=12, frameon=True, fancybox=True, framealpha=0.8,
  81.           loc='upper left', bbox_to_anchor=(1, 1))
  83. # 添加趋势线
  84. z = np.polyfit(df['Year'], df['Product_A'], 1)
  85. p = np.poly1d(z)
  86. ax.plot(df['Year'], p(df['Year']), linestyle=':', color='red', alpha=0.7, label='产品A趋势')
  87. ax.legend(fontsize=12, frameon=True, fancybox=True, framealpha=0.8,
  88.           loc='upper left', bbox_to_anchor=(1, 1))
  90. # 调整边距
  91. plt.tight_layout()
  92. plt.show()
复制代码

性能优化

当处理大量数据时，可视化可能会变得缓慢。以下是一些优化性能的技巧：
  2. import pandas as pd
  3. import matplotlib.pyplot as plt
  4. import numpy as np
  5. import time
  7. # 创建大量数据
  8. np.random.seed(42)
  9. n = 1000000  # 100万数据点
  10. x = np.random.randn(n)
  11. y = x * 0.5 + np.random.randn(n) * 0.5
  13. # 创建DataFrame
  14. df = pd.DataFrame({'X': x, 'Y': y})
  16. # 方法1：直接绘制所有数据（慢）
  17. start_time = time.time()
  18. plt.figure(figsize=(10, 6))
  19. plt.scatter(df['X'], df['Y'], alpha=0.1)
  20. plt.title('直接绘制所有数据点')
  21. print(f"直接绘制所有数据点耗时: {time.time() - start_time:.2f}秒")
  22. plt.show()
  24. # 方法2：使用数据采样（快）
  25. sample_size = 10000  # 采样1万个点
  26. df_sampled = df.sample(sample_size)
  28. start_time = time.time()
  29. plt.figure(figsize=(10, 6))
  30. plt.scatter(df_sampled['X'], df_sampled['Y'], alpha=0.5)
  31. plt.title('使用数据采样')
  32. print(f"使用数据采样耗时: {time.time() - start_time:.2f}秒")
  33. plt.show()
  35. # 方法3：使用2D直方图（快）
  36. start_time = time.time()
  37. plt.figure(figsize=(10, 6))
  38. plt.hist2d(df['X'], df['Y'], bins=50, cmap='viridis')
  39. plt.colorbar()
  40. plt.title('使用2D直方图')
  41. print(f"使用2D直方图耗时: {time.time() - start_time:.2f}秒")
  42. plt.show()
  44. # 方法4：使用六边形分箱图（快）
  45. start_time = time.time()
  46. plt.figure(figsize=(10, 6))
  47. plt.hexbin(df['X'], df['Y'], gridsize=50, cmap='viridis')
  48. plt.colorbar()
  49. plt.title('使用六边形分箱图')
  50. print(f"使用六边形分箱图耗时: {time.time() - start_time:.2f}秒")
  51. plt.show()
  53. # 方法5：使用数据聚合（快）
  54. # 创建网格
  55. x_bins = np.linspace(df['X'].min(), df['X'].max(), 50)
  56. y_bins = np.linspace(df['Y'].min(), df['Y'].max(), 50)
  58. # 计算每个网格中的点数
  59. x_idx = np.digitize(df['X'], x_bins)
  60. y_idx = np.digitize(df['Y'], y_bins)
  62. # 创建聚合数据
  63. grid_data = pd.DataFrame({'x_idx': x_idx, 'y_idx': y_idx})
  64. grid_counts = grid_data.groupby(['x_idx', 'y_idx']).size().reset_index(name='count')
  66. # 创建网格坐标
  67. grid_data['x_center'] = x_bins[grid_data['x_idx']-1] + (x_bins[1] - x_bins[0]) / 2
  68. grid_data['y_center'] = y_bins[grid_data['y_idx']-1] + (y_bins[1] - y_bins[0]) / 2
  70. # 合并计数
  71. grid_data = grid_data.merge(grid_counts, on=['x_idx', 'y_idx'], how='left').fillna(0)
  73. start_time = time.time()
  74. plt.figure(figsize=(10, 6))
  75. plt.scatter(grid_data['x_center'], grid_data['y_center'],
  76.             s=grid_data['count']/100, alpha=0.5, c=grid_data['count'], cmap='viridis')
  77. plt.colorbar()
  78. plt.title('使用数据聚合')
  79. print(f"使用数据聚合耗时: {time.time() - start_time:.2f}秒")
  80. plt.show()
复制代码

总结

Matplotlib与Pandas的集成为Python数据分析和可视化提供了强大的工具链。通过本文的介绍，我们了解了如何将这两个库有效地结合使用，从基础的数据处理到高级的可视化技巧。

主要要点包括：

1. 基础集成：Pandas内置了对Matplotlib的支持，可以直接使用DataFrame和Series的plot()方法进行基本绘图。
2. 灵活绘图：除了使用Pandas的内置绘图功能外，我们还可以直接使用Matplotlib来绘制Pandas数据，这提供了更多的自定义选项。
3. 实战应用：通过销售数据、股票数据和人口统计数据的分析案例，我们展示了如何在实际项目中应用这些工具。
4. 高级技巧：包括自定义图表样式、多子图布局、交互式可视化和动画可视化等高级技巧，可以帮助我们创建更加专业和吸引人的可视化效果。
5. 最佳实践：良好的数据准备与清洗、选择合适的图表类型、图表美化与标注以及性能优化等最佳实践，可以帮助我们提高数据可视化的质量和效率。

基础集成：Pandas内置了对Matplotlib的支持，可以直接使用DataFrame和Series的plot()方法进行基本绘图。

灵活绘图：除了使用Pandas的内置绘图功能外，我们还可以直接使用Matplotlib来绘制Pandas数据，这提供了更多的自定义选项。

实战应用：通过销售数据、股票数据和人口统计数据的分析案例，我们展示了如何在实际项目中应用这些工具。

高级技巧：包括自定义图表样式、多子图布局、交互式可视化和动画可视化等高级技巧，可以帮助我们创建更加专业和吸引人的可视化效果。

最佳实践：良好的数据准备与清洗、选择合适的图表类型、图表美化与标注以及性能优化等最佳实践，可以帮助我们提高数据可视化的质量和效率。

通过掌握Matplotlib与Pandas的集成应用，我们可以实现从数据处理到可视化展示的无缝对接，大大提高数据分析的效率和效果。希望本文能够帮助读者更好地利用这两大工具进行数据分析和可视化工作。
可视化
「七転び八起き（ななころびやおき）」
回复

使用道具 举报

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

本版积分规则

友情链接

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

加入Discord频道

加入QQ社群

加入QQ社群

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

Powered by Pixtech

© 2025-2026 Pixtech Team.