使用 NumPy 和 Matplotlib 实现交互式数据可视化

油墨香^_^

304人浏览 · 2026-06-25 20:47:07

油墨香^_^ · 2026-06-25 20:47:07 发布

1. 引言

数据可视化是数据科学中不可或缺的一环，它能够将抽象的数字转化为直观的图形，帮助人们理解数据背后的模式、趋势和异常。然而，静态图表往往只能呈现数据的一个侧面，无法满足探索性数据分析的需求。交互式数据可视化通过允许用户动态调整参数、选择数据子集、缩放平移图形等方式，让用户与数据进行“对话”，从而更深入地挖掘信息。

Python 生态中，NumPy 和 Matplotlib 是最基础也最强大的两个库。NumPy 提供了高效的多维数组操作，是科学计算的基石；Matplotlib 则以其灵活的绘图接口成为可视化领域的常青树。虽然 Matplotlib 默认生成静态图像，但借助其丰富的交互功能，我们可以轻松构建出具有响应式界面的可视化应用。

本文旨在提供一份详尽的教程，从零开始，手把手教你如何使用 NumPy 和 Matplotlib 实现交互式数据可视化。内容涵盖环境配置、基础绘图、交互组件、动画制作、实时数据流，以及综合案例。全文约 2 万字，包含大量可直接运行的代码示例，适合数据科学家、工程师和所有对数据可视化感兴趣的读者。

2. 环境搭建

在开始之前，确保你的计算机上安装了 Python 以及必要的库。推荐使用 Python 3.8 或更高版本。

2.1 安装 Python

访问 python.org 下载并安装 Python。安装时勾选“Add Python to PATH”选项。

2.2 安装 NumPy 和 Matplotlib

打开命令行（终端或命令提示符），执行以下命令：

bash

pip install numpy matplotlib

如果需要安装其他辅助库（如 Jupyter Notebook），可以一并安装：

bash

pip install jupyter

2.3 验证安装

在 Python 交互环境中运行以下代码，确认无报错：

python

import numpy as np
import matplotlib.pyplot as plt

print(np.__version__)
print(plt.__version__)

如果输出版本号，说明安装成功。

2.4 开发环境选择

你可以使用任何文本编辑器编写代码，但强烈推荐 Jupyter Notebook 或 JupyterLab，因为它们支持在浏览器中交互式运行代码，并直接显示图形。对于复杂的交互式应用，也可以使用 PyCharm、VS Code 等 IDE。

3. NumPy 基础回顾

NumPy 是 Python 科学计算的核心库，提供了多维数组对象 ndarray 以及大量数学函数。在本教程中，我们将频繁使用 NumPy 生成和操作数据。

3.1 创建数组

python

import numpy as np

# 从列表创建
a = np.array([1, 2, 3, 4])

# 使用内置函数
b = np.zeros((3, 4))          # 全零矩阵
c = np.ones((2, 3))           # 全一矩阵
d = np.arange(0, 10, 0.5)     # 等差数列
e = np.linspace(0, 1, 5)      # 等间距序列
f = np.random.rand(100)       # 均匀分布随机数
g = np.random.randn(100)      # 标准正态分布随机数

3.2 数组属性与操作

python

x = np.random.rand(5, 3)
print(x.shape)        # 形状 (5, 3)
print(x.ndim)         # 维度数 2
print(x.size)         # 元素总数 15
print(x.dtype)        # 数据类型，如 float64

# 索引与切片
x[0, 1]               # 第一行第二列
x[:, 1]               # 所有行的第二列
x[1:3, :]             # 第二行到第三行所有列

3.3 常用数学函数

NumPy 提供了向量化的数学运算，无需循环即可对数组所有元素操作：

python

x = np.linspace(-2*np.pi, 2*np.pi, 100)
y_sin = np.sin(x)
y_cos = np.cos(x)
y_exp = np.exp(-x**2 / 2)   # 高斯函数

这些函数将直接应用于数组的每个元素，返回新数组。

3.4 用于可视化的典型数据生成

在可视化中，我们常需要生成网格数据（如曲面图）、随机数据（如散点图）、时序数据（如信号）等。下面是一些例子：

python

# 二维网格数据
X, Y = np.meshgrid(np.linspace(-3, 3, 100), np.linspace(-3, 3, 100))
Z = np.sin(X) * np.cos(Y)

# 带有噪声的正弦波
t = np.linspace(0, 10, 500)
signal = np.sin(2 * np.pi * 1 * t) + 0.5 * np.random.randn(500)

# 聚类散点数据
from sklearn.datasets import make_blobs  # 注意：需要安装 scikit-learn，但此处仅为示例
X, y = make_blobs(n_samples=300, centers=3, cluster_std=0.6, random_state=0)

4. Matplotlib 基础绘图

Matplotlib 的绘图接口主要分为两种：pyplot 模块（类似 MATLAB）和面向对象的 Axes 对象。为便于交互，我们通常使用面向对象的方式，因为它提供了更精细的控制。

4.1 基本绘图函数

python

import matplotlib.pyplot as plt

# 创建画布和坐标系
fig, ax = plt.subplots()

# 绘制线图
x = np.linspace(0, 10, 100)
y = np.sin(x)
ax.plot(x, y, label='sin(x)', color='blue', linestyle='-', linewidth=2)

# 散点图
x_scatter = np.random.rand(50)
y_scatter = np.random.rand(50)
ax.scatter(x_scatter, y_scatter, color='red', alpha=0.5, label='random points')

# 柱状图
categories = ['A', 'B', 'C']
values = [15, 30, 45]
ax.bar(categories, values, color='green')

# 设置标签和标题
ax.set_xlabel('X axis')
ax.set_ylabel('Y axis')
ax.set_title('Example Plot')
ax.legend()

# 显示网格
ax.grid(True)

plt.show()

4.2 子图与布局

当需要同时展示多个图形时，可以使用 subplots 创建多个子图：

python

fig, axes = plt.subplots(2, 2, figsize=(10, 8))  # 2行2列
axes[0, 0].plot(x, y)
axes[0, 1].scatter(x_scatter, y_scatter)
axes[1, 0].bar(categories, values)
axes[1, 1].hist(np.random.randn(1000), bins=30)
plt.tight_layout()
plt.show()

4.3 样式定制

Matplotlib 支持多种内置样式，可以通过 plt.style.available 查看所有可用样式，并通过 plt.style.use('style_name') 应用。

python

plt.style.use('ggplot')
fig, ax = plt.subplots()
ax.plot(x, y)
ax.set_title('ggplot style')
plt.show()

也可以手动调整颜色、线条、字体等，Matplotlib 提供了丰富的参数。

5. 交互式功能入门

Matplotlib 本身是一个静态绘图库，但它支持多种交互功能，包括交互模式、事件处理和GUI 控件。

5.1 交互模式

默认情况下，plt.show() 会阻塞程序，直到关闭图形窗口。若想在绘图后继续执行代码，可以启用交互模式：

python

plt.ion()  # 打开交互模式
fig, ax = plt.subplots()
ax.plot([0, 1], [0, 1])
plt.draw()
plt.pause(0.1)  # 短暂暂停以更新图形

# 后续可以继续添加内容
ax.plot([0, 1], [1, 0], 'r--')
plt.draw()

注意：在 Jupyter Notebook 中，通常不需要显式调用 plt.ion()，因为图形会自动更新。

5.2 事件处理基础

Matplotlib 允许将鼠标和键盘事件绑定到自定义函数。事件类型包括 'button_press_event'、'key_press_event'、'motion_notify_event' 等。

python

def on_click(event):
    if event.inaxes:
        print(f"Clicked at ({event.xdata:.2f}, {event.ydata:.2f})")

def on_key(event):
    print(f"Pressed key: {event.key}")

fig, ax = plt.subplots()
ax.plot(np.random.rand(10), 'o-')
fig.canvas.mpl_connect('button_press_event', on_click)
fig.canvas.mpl_connect('key_press_event', on_key)
plt.show()

5.3 使用 matplotlib.widgets 模块

Matplotlib 提供了几个预制的控件（widgets），如滑块、按钮、单选按钮、复选框等，可以非常方便地添加到图形中。

滑块 (Slider)

python

from matplotlib.widgets import Slider

fig, ax = plt.subplots()
plt.subplots_adjust(bottom=0.25)  # 为滑块留出空间

t = np.linspace(0, 2*np.pi, 200)
freq = 1
y = np.sin(freq * t)
line, = ax.plot(t, y)

# 创建滑块轴
ax_slider = plt.axes([0.2, 0.1, 0.6, 0.03])
slider = Slider(ax_slider, 'Frequency', 0.1, 10.0, valinit=freq)

def update(val):
    freq = slider.val
    line.set_ydata(np.sin(freq * t))
    fig.canvas.draw_idle()

slider.on_changed(update)
plt.show()

按钮 (Button)

python

from matplotlib.widgets import Button

fig, ax = plt.subplots()
ax.plot(np.random.rand(10), 'o-')
ax.set_title('Click to regenerate')

def regenerate(event):
    ax.lines[0].set_ydata(np.random.rand(10))
    fig.canvas.draw_idle()

ax_button = plt.axes([0.8, 0.05, 0.1, 0.075])
button = Button(ax_button, 'Regenerate')
button.on_clicked(regenerate)
plt.show()

单选按钮 (RadioButtons)

python

from matplotlib.widgets import RadioButtons

fig, ax = plt.subplots()
t = np.linspace(0, 2*np.pi, 200)
line, = ax.plot(t, np.sin(t))
ax.set_ylim(-1.5, 1.5)

ax_radio = plt.axes([0.02, 0.5, 0.15, 0.15])
radio = RadioButtons(ax_radio, ('sin', 'cos', 'tan'), active=0)

def func(label):
    if label == 'sin':
        line.set_ydata(np.sin(t))
    elif label == 'cos':
        line.set_ydata(np.cos(t))
    elif label == 'tan':
        line.set_ydata(np.tan(t))
    fig.canvas.draw_idle()

radio.on_clicked(func)
plt.show()

这些控件非常适合构建简单的交互式工具，无需学习复杂的 GUI 框架。

6. 实现交互式数据探索

有了以上基础，我们可以开始构建更具实用性的交互式数据探索工具。

6.1 使用滑块调整参数

假设我们想观察一个函数 f(x) = A * sin(2πf x + φ) 随振幅 A、频率 f 和相位 φ 的变化。我们可以创建三个滑块分别控制这些参数。

python

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.widgets import Slider

fig, ax = plt.subplots()
plt.subplots_adjust(left=0.1, bottom=0.3)

x = np.linspace(0, 2, 1000)
A0, f0, phi0 = 1, 1, 0
y0 = A0 * np.sin(2 * np.pi * f0 * x + phi0)
line, = ax.plot(x, y0, lw=2)
ax.set_xlim(0, 2)
ax.set_ylim(-1.5, 1.5)

# 创建滑块
ax_A = plt.axes([0.1, 0.2, 0.65, 0.03])
ax_f = plt.axes([0.1, 0.15, 0.65, 0.03])
ax_phi = plt.axes([0.1, 0.1, 0.65, 0.03])

slider_A = Slider(ax_A, 'Amplitude', 0, 2, valinit=A0)
slider_f = Slider(ax_f, 'Frequency', 0.1, 5, valinit=f0)
slider_phi = Slider(ax_phi, 'Phase', -np.pi, np.pi, valinit=phi0)

def update(val):
    A = slider_A.val
    f = slider_f.val
    phi = slider_phi.val
    y = A * np.sin(2 * np.pi * f * x + phi)
    line.set_ydata(y)
    fig.canvas.draw_idle()

slider_A.on_changed(update)
slider_f.on_changed(update)
slider_phi.on_changed(update)

plt.show()

6.2 按钮控制动画播放

结合按钮和动画，可以控制是否连续更新参数。例如，让频率随时间自动变化，同时提供启动/停止按钮。

python

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.widgets import Button, Slider
import time

fig, ax = plt.subplots()
plt.subplots_adjust(bottom=0.2)

x = np.linspace(0, 2, 1000)
f = 1
y = np.sin(2 * np.pi * f * x)
line, = ax.plot(x, y)
ax.set_ylim(-1.2, 1.2)

# 添加滑块控制频率
ax_freq = plt.axes([0.2, 0.05, 0.6, 0.03])
slider_freq = Slider(ax_freq, 'Frequency', 0.1, 5, valinit=f)

# 添加启动/停止按钮
ax_start = plt.axes([0.8, 0.9, 0.1, 0.05])
button_start = Button(ax_start, 'Start')
ax_stop = plt.axes([0.8, 0.84, 0.1, 0.05])
button_stop = Button(ax_stop, 'Stop')

running = False
t0 = 0

def animate():
    global t0
    while running:
        current_time = time.time() - t0
        freq = slider_freq.val
        # 让相位随时间线性增加，实现连续扫频效果
        y = np.sin(2 * np.pi * freq * x + current_time * 2 * np.pi)
        line.set_ydata(y)
        fig.canvas.draw_idle()
        plt.pause(0.05)

def start(event):
    global running, t0
    if not running:
        running = True
        t0 = time.time()
        animate()

def stop(event):
    global running
    running = False

button_start.on_clicked(start)
button_stop.on_clicked(stop)
slider_freq.on_changed(lambda val: None)  # 只是为了在滑块变化时更新

plt.show()

注意：上面的 animate 函数在主线程中运行，会阻塞 GUI 事件循环。更好的做法是使用 FuncAnimation（见下一节）。

6.3 鼠标交互：拾取数据点

在散点图中，用户点击某个点，我们希望高亮该点并显示其坐标。

python

import numpy as np
import matplotlib.pyplot as plt

fig, ax = plt.subplots()
np.random.seed(0)
x = np.random.rand(50)
y = np.random.rand(50)
sc = ax.scatter(x, y, picker=True)  # 启用拾取

# 用于高亮的圆点
highlight, = ax.plot([], [], 'ro', markersize=10)

def on_pick(event):
    ind = event.ind[0]
    highlight.set_data([x[ind]], [y[ind]])
    fig.canvas.draw_idle()
    print(f"Picked point {ind}: ({x[ind]:.3f}, {y[ind]:.3f})")

fig.canvas.mpl_connect('pick_event', on_pick)
plt.show()

6.4 实时数据流模拟

假设我们正在从传感器读取数据，需要实时绘制波形。我们可以使用 plt.ion() 或 FuncAnimation 实现。

python

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

fig, ax = plt.subplots()
xdata, ydata = [], []
line, = ax.plot([], [], 'r-')
ax.set_xlim(0, 100)
ax.set_ylim(-1.5, 1.5)
ax.set_xlabel('Time')
ax.set_ylabel('Value')

def data_gen():
    """生成模拟数据"""
    t = 0
    while True:
        val = np.sin(2 * np.pi * 0.1 * t) + 0.2 * np.random.randn()
        yield t, val
        t += 1

def update(data):
    t, val = data
    xdata.append(t)
    ydata.append(val)
    if t > 100:
        ax.set_xlim(t-100, t)  # 滚动窗口
    line.set_data(xdata, ydata)
    return line,

ani = animation.FuncAnimation(fig, update, data_gen, blit=True, interval=50)
plt.show()

FuncAnimation 是创建动画的标准方式，它会自动调用 update 函数并重绘。

7. 动画与实时数据流

Matplotlib 的 animation 模块提供了创建动画的简便方法。除了 FuncAnimation，还有 ArtistAnimation，但 FuncAnimation 更常用。

7.1 FuncAnimation 详解

FuncAnimation 的核心参数：

fig：画布对象
func：每一帧调用的函数
frames：帧的迭代器或整数（帧数）
interval：帧之间的间隔（毫秒）
repeat：是否重复
blit：是否只重绘变化的部分（提高性能）

示例：移动的正弦波

python

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

fig, ax = plt.subplots()
x = np.linspace(0, 2*np.pi, 200)
line, = ax.plot(x, np.sin(x))
ax.set_ylim(-1.5, 1.5)

def animate(i):
    line.set_ydata(np.sin(x + i / 10.0))  # 相位随时间移动
    return line,

ani = animation.FuncAnimation(fig, animate, frames=200, interval=50, blit=True)
plt.show()

7.2 实时数据更新（模拟传感器）

更真实的场景：传感器每隔一段时间返回一个数据点，我们将其附加到现有数据并更新图形。

python

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from collections import deque

fig, ax = plt.subplots()
max_len = 200
data = deque(maxlen=max_len)  # 固定长度的队列
line, = ax.plot([], [])
ax.set_xlim(0, max_len)
ax.set_ylim(-3, 3)

def update(frame):
    # 模拟新数据点
    new_val = np.sin(frame * 0.1) + 0.2 * np.random.randn()
    data.append(new_val)
    line.set_data(range(len(data)), data)
    # 调整 x 轴范围，保持窗口固定
    if len(data) == max_len:
        ax.set_xlim(0, max_len)
    return line,

ani = animation.FuncAnimation(fig, update, frames=None, interval=100, blit=True)
plt.show()

7.3 交互式动画控制

我们可以结合按钮来启动/停止动画，甚至调整动画速度。

python

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from matplotlib.widgets import Button

fig, ax = plt.subplots()
x = np.linspace(0, 2*np.pi, 200)
line, = ax.plot(x, np.sin(x))
ax.set_ylim(-1.5, 1.5)

# 动画对象
ani = None
running = True

def animate(i):
    line.set_ydata(np.sin(x + i / 10.0))
    return line,

def start(event):
    global ani, running
    if ani is None or not running:
        ani = animation.FuncAnimation(fig, animate, frames=200, interval=50, blit=True, repeat=True)
        running = True

def stop(event):
    global ani, running
    if ani is not None:
        ani.event_source.stop()
        running = False

# 按钮
ax_start = plt.axes([0.7, 0.05, 0.1, 0.05])
ax_stop = plt.axes([0.81, 0.05, 0.1, 0.05])
btn_start = Button(ax_start, 'Start')
btn_stop = Button(ax_stop, 'Stop')
btn_start.on_clicked(start)
btn_stop.on_clicked(stop)

# 初始启动动画
start(None)
plt.show()

8. 高级交互：与 GUI 后端集成

虽然 Matplotlib 自带交互功能，但有时我们需要更复杂的 GUI 界面，例如使用 PyQt、Tkinter 等框架。Matplotlib 可以无缝嵌入到这些 GUI 中。

8.1 嵌入到 Tkinter

python

import tkinter as tk
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2Tk
from matplotlib.figure import Figure
import numpy as np

root = tk.Tk()
root.title("Embedded Matplotlib")

# 创建 Figure 和 Axes
fig = Figure(figsize=(5, 4), dpi=100)
ax = fig.add_subplot(111)
t = np.linspace(0, 2*np.pi, 200)
ax.plot(t, np.sin(t))

# 创建画布并嵌入
canvas = FigureCanvasTkAgg(fig, master=root)
canvas.draw()
canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)

# 添加工具栏
toolbar = NavigationToolbar2Tk(canvas, root)
toolbar.update()
canvas.get_tk_widget().pack(side=tk.TOP, fill=tk.BOTH, expand=1)

# 添加一个简单的滑块控件（使用 tkinter 的 Scale）
def update_freq(val):
    freq = float(val)
    y = np.sin(freq * t)
    ax.clear()
    ax.plot(t, y)
    canvas.draw()

slider = tk.Scale(root, from_=0.1, to=5, orient=tk.HORIZONTAL, label='Frequency', command=update_freq)
slider.pack(side=tk.BOTTOM, fill=tk.X)

root.mainloop()

8.2 嵌入到 PyQt5

PyQt5 是另一个常用的 GUI 库。首先需要安装 PyQt5：

bash

pip install pyqt5

python

import sys
import numpy as np
from PyQt5.QtWidgets import QApplication, QMainWindow, QVBoxLayout, QWidget, QSlider
from PyQt5.QtCore import Qt
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.figure import Figure

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Embedded Matplotlib in PyQt5")
        self.setGeometry(100, 100, 800, 600)

        central_widget = QWidget()
        self.setCentralWidget(central_widget)
        layout = QVBoxLayout(central_widget)

        # Matplotlib 画布
        self.figure = Figure(figsize=(5, 4), dpi=100)
        self.canvas = FigureCanvas(self.figure)
        self.ax = self.figure.add_subplot(111)
        layout.addWidget(self.canvas)

        # 滑块
        self.slider = QSlider(Qt.Horizontal)
        self.slider.setMinimum(1)
        self.slider.setMaximum(100)
        self.slider.setValue(50)
        self.slider.valueChanged.connect(self.update_plot)
        layout.addWidget(self.slider)

        self.t = np.linspace(0, 2*np.pi, 200)
        self.update_plot(50)

    def update_plot(self, value):
        freq = value / 10.0
        y = np.sin(freq * self.t)
        self.ax.clear()
        self.ax.plot(self.t, y)
        self.ax.set_ylim(-1.5, 1.5)
        self.ax.set_title(f'Frequency = {freq:.1f}')
        self.canvas.draw()

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec_())

8.3 使用 mpl_connect 定制复杂交互

当嵌入到 GUI 中时，Matplotlib 的事件仍然可以通过 mpl_connect 使用，并与 GUI 事件协同工作。例如，在 Tkinter 中，鼠标点击 Matplotlib 图形时弹出信息。

python

# 在上面的 Tkinter 示例中添加
def on_click(event):
    if event.inaxes:
        print(f"Clicked at ({event.xdata:.2f}, {event.ydata:.2f})")

canvas.mpl_connect('button_press_event', on_click)

9. 综合案例

为了巩固所学，我们设计几个综合案例，涵盖不同场景。

9.1 案例1：函数绘图仪（参数调节）

功能：绘制一个自定义函数 f(x) = a * exp(-b * x^2) * sin(c * x)，通过滑块实时调整参数 a, b, c。

实现：使用 Matplotlib 的滑块，并显示当前参数值。

python

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.widgets import Slider, TextBox

fig, ax = plt.subplots(figsize=(8, 5))
plt.subplots_adjust(bottom=0.3)

x = np.linspace(-3, 3, 500)
a0, b0, c0 = 1, 1, 2
y0 = a0 * np.exp(-b0 * x**2) * np.sin(c0 * x)
line, = ax.plot(x, y0, lw=2)
ax.set_xlim(-3, 3)
ax.set_ylim(-1.5, 1.5)
ax.set_xlabel('x')
ax.set_ylabel('f(x)')
ax.set_title('Interactive Function Plotter')

# 滑块轴
ax_a = plt.axes([0.2, 0.2, 0.6, 0.03])
ax_b = plt.axes([0.2, 0.15, 0.6, 0.03])
ax_c = plt.axes([0.2, 0.1, 0.6, 0.03])

slider_a = Slider(ax_a, 'a', 0, 2, valinit=a0)
slider_b = Slider(ax_b, 'b', 0, 2, valinit=b0)
slider_c = Slider(ax_c, 'c', 0, 5, valinit=c0)

# 文本框显示当前值
ax_text = plt.axes([0.02, 0.9, 0.2, 0.05])
text_box = TextBox(ax_text, 'Current: ', initial=f'a={a0}, b={b0}, c={c0}')

def update(val):
    a = slider_a.val
    b = slider_b.val
    c = slider_c.val
    y = a * np.exp(-b * x**2) * np.sin(c * x)
    line.set_ydata(y)
    text_box.set_val(f'a={a:.2f}, b={b:.2f}, c={c:.2f}')
    fig.canvas.draw_idle()

slider_a.on_changed(update)
slider_b.on_changed(update)
slider_c.on_changed(update)

plt.show()

9.2 案例2：散点图数据筛选器

功能：生成二维散点数据（两个高斯簇），用户可以通过滑块调整分离程度，或通过复选框选择显示哪个簇。

实现：使用滑块控制簇间距，使用 RadioButtons 选择显示簇。

python

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.widgets import Slider, RadioButtons

# 生成数据：两个高斯簇
np.random.seed(42)
cluster1 = np.random.randn(100, 2) + np.array([-2, 0])
cluster2 = np.random.randn(100, 2) + np.array([2, 0])

fig, ax = plt.subplots()
plt.subplots_adjust(bottom=0.2, left=0.1)

scatter1 = ax.scatter(cluster1[:,0], cluster1[:,1], c='red', label='Cluster A')
scatter2 = ax.scatter(cluster2[:,0], cluster2[:,1], c='blue', label='Cluster B')
ax.legend()
ax.set_xlim(-5, 5)
ax.set_ylim(-3, 3)

# 滑块：控制簇间距
ax_slider = plt.axes([0.2, 0.05, 0.6, 0.03])
slider = Slider(ax_slider, 'Separation', 0, 5, valinit=2)

# 单选按钮：选择显示哪个簇
ax_radio = plt.axes([0.02, 0.5, 0.12, 0.1])
radio = RadioButtons(ax_radio, ('Both', 'A', 'B'), active=0)

def update_separation(sep):
    # 重新生成簇，中心距离为 sep
    cluster1_new = np.random.randn(100, 2) + np.array([-sep/2, 0])
    cluster2_new = np.random.randn(100, 2) + np.array([sep/2, 0])
    scatter1.set_offsets(cluster1_new)
    scatter2.set_offsets(cluster2_new)
    fig.canvas.draw_idle()

def update_display(label):
    if label == 'Both':
        scatter1.set_visible(True)
        scatter2.set_visible(True)
    elif label == 'A':
        scatter1.set_visible(True)
        scatter2.set_visible(False)
    elif label == 'B':
        scatter1.set_visible(False)
        scatter2.set_visible(True)
    fig.canvas.draw_idle()

slider.on_changed(update_separation)
radio.on_clicked(update_display)

plt.show()

9.3 案例3：实时频谱分析仪

功能：模拟从麦克风采集音频数据，实时显示时域波形和频谱图（使用 FFT）。通过滑块调整显示的时间窗口长度。

实现：使用 FuncAnimation 持续生成模拟音频信号，并更新时域和频域子图。

python

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from matplotlib.widgets import Slider

# 参数
fs = 1000  # 采样率 Hz
duration = 1  # 每次显示的时间窗口（秒）
n_samples = int(fs * duration)
freq_range = (0, 200)  # 显示频率范围

fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8))
plt.subplots_adjust(bottom=0.2)

# 时域
ax1.set_xlim(0, duration)
ax1.set_ylim(-1.5, 1.5)
ax1.set_ylabel('Amplitude')
ax1.set_title('Time Domain')
line_time, = ax1.plot([], [], 'b-')

# 频域
ax2.set_xlim(*freq_range)
ax2.set_ylim(0, 100)
ax2.set_xlabel('Frequency (Hz)')
ax2.set_ylabel('Magnitude')
ax2.set_title('Frequency Domain')
line_freq, = ax2.plot([], [], 'r-')

# 滑块控制时间窗口长度
ax_slider = plt.axes([0.2, 0.05, 0.6, 0.03])
slider = Slider(ax_slider, 'Window (s)', 0.1, 2, valinit=duration)

def generate_signal(t):
    # 模拟包含多个频率成分的信号
    signal = (0.5 * np.sin(2 * np.pi * 50 * t) +
              0.3 * np.sin(2 * np.pi * 120 * t) +
              0.2 * np.random.randn(len(t)))
    return signal

# 全局变量
t_data = np.linspace(0, duration, n_samples)
y_data = generate_signal(t_data)

def update_window(val):
    global duration, n_samples, t_data, y_data
    duration = slider.val
    n_samples = int(fs * duration)
    t_data = np.linspace(0, duration, n_samples)
    y_data = generate_signal(t_data)

slider.on_changed(update_window)

def animate(frame):
    global y_data
    # 模拟新数据：滚动更新，每次丢弃最旧的一部分，并添加新数据
    # 为了简单，这里直接重新生成新数据（实际应用中应该使用缓冲队列）
    y_data = np.roll(y_data, -n_samples//10)
    new_segment = generate_signal(np.linspace(0, duration, n_samples//10))
    y_data[-n_samples//10:] = new_segment

    # 更新时域
    line_time.set_data(t_data, y_data)
    ax1.relim()
    ax1.autoscale_view(scalex=False, scaley=True)

    # 更新频域（FFT）
    fft_vals = np.fft.rfft(y_data)
    fft_freq = np.fft.rfftfreq(n_samples, 1/fs)
    magnitude = np.abs(fft_vals) / n_samples * 2
    line_freq.set_data(fft_freq, magnitude)
    ax2.relim()
    ax2.autoscale_view(scalex=True, scaley=True)

    return line_time, line_freq

ani = animation.FuncAnimation(fig, animate, interval=100, blit=True)
plt.show()

9.4 案例4：三维数据交互

Matplotlib 也支持三维绘图（mplot3d）。结合交互控件，我们可以实现三维曲面的动态调整。

功能：绘制曲面 z = sin(sqrt(x^2+y^2))，通过滑块控制网格密度、视角等。

python

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.widgets import Slider
from mpl_toolkits.mplot3d import Axes3D

fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')
plt.subplots_adjust(bottom=0.2)

# 初始网格
res = 50
x = np.linspace(-5, 5, res)
y = np.linspace(-5, 5, res)
X, Y = np.meshgrid(x, y)
Z = np.sin(np.sqrt(X**2 + Y**2))

surf = ax.plot_surface(X, Y, Z, cmap='viridis', alpha=0.8)
ax.set_xlabel('X')
ax.set_ylabel('Y')
ax.set_zlabel('Z')

# 滑块：分辨率
ax_res = plt.axes([0.2, 0.05, 0.6, 0.03])
slider_res = Slider(ax_res, 'Resolution', 20, 200, valinit=res, valstep=10)

def update_res(val):
    res = int(slider_res.val)
    x = np.linspace(-5, 5, res)
    y = np.linspace(-5, 5, res)
    X, Y = np.meshgrid(x, y)
    Z = np.sin(np.sqrt(X**2 + Y**2))
    ax.clear()
    ax.plot_surface(X, Y, Z, cmap='viridis', alpha=0.8)
    ax.set_xlabel('X')
    ax.set_ylabel('Y')
    ax.set_zlabel('Z')
    fig.canvas.draw_idle()

slider_res.on_changed(update_res)
plt.show()

10. 性能优化与最佳实践

当处理大量数据或高频率更新时，性能会成为瓶颈。以下是一些优化技巧。

10.1 避免重绘全部图形

在交互式更新中，使用 set_data 更新线条或散点图的数据，而不是清除整个 Axes 后重新绘制。这可以大幅减少重绘开销。

python

# 低效方式
ax.clear()
ax.plot(new_x, new_y)
fig.canvas.draw()

# 高效方式
line.set_data(new_x, new_y)
fig.canvas.draw_idle()

对于散点图，使用 set_offsets。

10.2 使用 blit 技术

FuncAnimation 中的 blit=True 仅重绘变化的部分，而不是整个图形。这需要动画函数返回要更新的艺术家对象列表。

python

def animate(i):
    line.set_ydata(...)
    return line,
ani = animation.FuncAnimation(fig, animate, blit=True)

10.3 合理设置数据采样率

在实时数据流中，数据点过多会导致绘图缓慢。可以通过下采样或限制数据点数量来改善性能。

python

max_points = 1000
if len(xdata) > max_points:
    xdata = xdata[-max_points:]
    ydata = ydata[-max_points:]

10.4 使用后台渲染

对于复杂的图形，可以使用 fig.canvas.blit 和后台渲染技术，但通常 blit=True 已足够。

10.5 避免在事件回调中执行耗时操作

如果事件回调函数中包含耗时计算（如大型 FFT），应该将计算放到单独线程中，或使用 fig.canvas.flush_events() 来保持 UI 响应。

11. 常见问题与解决方案

11.1 交互不响应

检查是否在 Jupyter Notebook 中：如果使用 %matplotlib inline，交互功能可能受限。应该使用 %matplotlib notebook 或 %matplotlib widget。
确保 GUI 后端支持：某些后端（如 'agg'）不支持交互。可以通过 import matplotlib; print(matplotlib.get_backend()) 查看当前后端。需要交互时应选择 'TkAgg', 'Qt5Agg', 'macosx' 等。
滑块/按钮没有更新图形：确认在回调函数中调用了 fig.canvas.draw_idle() 或 plt.draw()。