Matplotlib实现动态散点图：旧数据点渐隐效果技术问询

我明白你的需求啦——要让动态散点图里的旧点慢慢变透明，新点保持清晰，而你现在的代码刚好反过来了。咱们来调整一下，有两种靠谱的方法可以实现这个效果：

方法一：单独管理每个散点对象的透明度 #

这个方法更直接，我们每次只画新生成的点，然后把这些散点对象存起来，在每一轮迭代中，给之前所有的旧点降低透明度，新点保持高透明度。这样就能实现旧点逐渐淡出的效果。

修改后的代码大概是这样的：

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

def plotter_fader(iterations = 100, stay_open = True):
    # 初始化绘图
    fig, ax = plt.subplots()
    plt.ion()
    ax.set_xlabel('X Axis', size = 12)
    ax.set_ylabel('Y Axis', size = 12)
    
    # 用来存储所有散点对象的列表
    scatter_points = []
    # 初始透明度和每轮下降的幅度
    initial_alpha = 1.0
    alpha_decay = initial_alpha / iterations

    # 假设A和B是初始点，这里随便设个例子值
    A = np.array([0, 0])
    B = np.array([10, 10])
    t_vals = np.linspace(0,1, iterations)

    for t in t_vals:
        # 生成中间点（这里用简单的线性插值当例子）
        intermediate = (1-t)*A + t*B
        # 模拟生成新的点，这里每次生成1个点，你可以换成自己的逻辑
        new_xvals = [intermediate[0]]
        new_yvals = [intermediate[1]]
        
        # 绘制新点，初始透明度1.0
        scatter = ax.scatter(new_xvals, new_yvals, '.', color='darkgray', alpha=initial_alpha)
        scatter_points.append(scatter)
        
        # 更新所有旧点的透明度
        for idx, s in enumerate(scatter_points[:-1]):
            current_alpha = s.get_alpha()
            if current_alpha > 0:
                s.set_alpha(current_alpha - alpha_decay)
        
        # 调整坐标轴范围
        ax.relim()
        ax.autoscale_view()
        ax.set_title('Time: %0.3f' %t)
        
        fig.canvas.draw()
        fig.canvas.flush_events()
        time.sleep(0.005)
    
    # 保持窗口打开
    while stay_open:
        fig.canvas.flush_events()

这个方法的好处是每个点的透明度变化完全可控，你可以调整alpha_decay来控制淡出的速度，比如想让旧点消失得更快，就把这个值调大。

方法二：用颜色映射（cmap）绑定时间戳 #

如果你偏好使用colormap来实现，那可以给每个点分配一个“时间权重”，越新的点权重越高，然后自定义一个colormap，让权重低的（旧点）透明度更低，权重高的（新点）透明度更高。

示例代码如下：

import matplotlib.pyplot as plt
import numpy as np
import time
from matplotlib.colors import LinearSegmentedColormap

def plotter_fader(iterations = 100, stay_open = True):
    fig, ax = plt.subplots()
    plt.ion()
    ax.set_xlabel('X Axis', size = 12)
    ax.set_ylabel('Y Axis', size = 12)
    
    x_data = []
    y_data = []
    time_weights = []  # 存储每个点的时间权重，值越大越新
    
    # 自定义colormap：颜色固定为深灰，透明度从0到1渐变
    cmap = LinearSegmentedColormap.from_list(
        'fade_cmap',
        [(0, 0.098, 0.098, 0.098, 0),  # 旧点：全透明
         (1, 0.098, 0.098, 0.098, 1)], # 新点：完全不透明
        N=iterations
    )
    
    A = np.array([0, 0])
    B = np.array([10, 10])
    t_vals = np.linspace(0,1, iterations)

    for t_idx, t in enumerate(t_vals):
        intermediate = (1-t)*A + t*B
        new_xvals = [intermediate[0]]
        new_yvals = [intermediate[1]]
        
        x_data.extend(new_xvals)
        y_data.extend(new_yvals)
        # 给新点分配当前迭代的索引作为权重（越大越新）
        time_weights.extend([t_idx]*len(new_xvals))
        
        # 清除当前轴的内容，然后用colormap重新绘制所有点
        ax.clear()
        ax.scatter(x_data, y_data, '.', c=time_weights, cmap=cmap)
        
        ax.relim()
        ax.autoscale_view()
        ax.set_title('Time: %0.3f' %t)
        ax.set_xlabel('X Axis', size = 12)
        ax.set_ylabel('Y Axis', size = 12)
        
        fig.canvas.draw()
        fig.canvas.flush_events()
        time.sleep(0.005)
    
    while stay_open:
        fig.canvas.flush_events()

这个方法的核心是用time_weights来标记每个点的新旧程度，然后通过自定义的colormap把权重映射到透明度上，每次重绘所有点的时候，旧点就会显示得更透明。

需要注意的是，第二种方法因为每次都要清除并重绘所有点，当迭代次数很多、点的数量很大时，性能可能会比第一种方法差一点。你可以根据自己的场景选择合适的方式。

内容的提问来源于stack exchange，提问作者Sandeep Silwal