如何用Matplotlib实现类似pygame flip的高速动画刷新？

我有一个基于Pygame的高速动画程序，运行效果很好，但因为技术限制，需要改用Matplotlib或者其他通用Python模块实现相同功能。

我的Pygame程序核心结构是这样的：

pygame.init()
SURF = pygame.display.set_mode((500, 500))
arr = pygame.surfarray.pixels2d(SURF) # numpy的视图，二维数组
while ok:
    # 修改arr中的部分像素
    pygame.display.flip()
pygame.quit()

我对Matplotlib的底层使用经验不多，但觉得肯定能实现等效功能——关键是怎么共享图形的位图缓冲区、修改像素然后高效刷新屏幕？

这里有个Pygame的最小可行示例，在我的电脑上能跑到250帧/秒（远超屏幕刷新率）：

import pygame,numpy,time
pygame.init()
size=(400,400)
SURF = pygame.display.set_mode(size)
arr = pygame.surfarray.pixels2d(SURF) # numpy缓冲区
t0=time.clock()
for counter in range(1000):
    arr[:]=numpy.random.randint(0,0xfffff,size)
    pygame.display.flip()
pygame.quit()
print(counter/(time.clock()-t0))

编辑：
我按照查到的方法试了下面的Matplotlib代码，但帧率只有20帧/秒，远达不到需求：

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import time # 补全原代码遗漏的导入

fig = plt.figure()
def f(x, y):
    return np.sin(x) + np.cos(y)

x = np.linspace(0, 2 * np.pi, 400)
y = np.linspace(0, 2 * np.pi, 400).reshape(-1, 1)
im = plt.imshow(f(x, y), animated=True)

count=0
t0=time.clock()+1

def updatefig(*args):
    global x, y,count,t0
    x += np.pi / 15.
    y += np.pi / 20.
    im.set_array(f(x, y))
    if time.clock()<t0:
        count+=1
    else:
        print (count)
        count=0
        t0=time.clock()+1
    return im,

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

Matplotlib默认的动画管线确实偏重于绘图而非高速像素操作，不过我们可以绕过一些上层封装，直接操作底层缓冲区来提升帧率。下面是几个关键优化点和实现方案：

1. 跳过Matplotlib上层渲染，直接操作像素缓冲区 #

Matplotlib的imshow会经过多层渲染流程，我们可以直接获取画布的底层像素数组，像Pygame那样修改后强制刷新，跳过不必要的中间步骤。

示例代码：直接操作Canvas缓冲区 #

import numpy as np
import matplotlib
matplotlib.use('Qt5Agg') # 优先选择性能较好的交互式后端
import matplotlib.pyplot as plt
import time

# 创建无冗余元素的窗口和画布
fig, ax = plt.subplots(figsize=(4,4), dpi=100)
ax.set_axis_off()
fig.subplots_adjust(left=0, right=1, top=1, bottom=0)

# 获取画布底层像素缓冲区（RGBA格式，形状为(高度, 宽度, 4)）
canvas = fig.canvas
canvas.draw()
buf = np.frombuffer(canvas.buffer_rgba(), dtype=np.uint8).reshape(canvas.get_width_height()[::-1] + (4,))

size = (400,400)
t0 = time.perf_counter()
count = 0

# 高速像素更新循环
try:
    while count < 1000:
        # 生成随机RGB像素数据，转换为RGBA格式（alpha通道设为255）
        rand_rgb = np.random.randint(0, 256, size + (3,), dtype=np.uint8)
        buf[:size[0], :size[1], :3] = rand_rgb
        buf[:size[0], :size[1], 3] = 255
        
        # 直接刷新画布区域，跳过Matplotlib重绘逻辑
        canvas.blit(ax.bbox)
        fig.canvas.flush_events()
        
        count += 1
finally:
    plt.close(fig)

print(f"帧率：{count/(time.perf_counter()-t0):.1f}帧/秒")

2. 关键优化细节 #

• 选对后端：优先用Qt5Agg/Qt6Agg，比默认的TkAgg性能高很多；如果不需要交互，Agg后端也能提速
• 砍掉冗余渲染：关闭坐标轴、取消子图边距，减少Matplotlib需要处理的元素
• 避免上层API开销：不要用FuncAnimation的默认更新逻辑，直接操作缓冲区是最快的方式

3. 替代方案：PIL + Tkinter（极致性能） #

如果Matplotlib还是达不到你的帧率要求，试试用Pillow直接操作图像，搭配Tkinter显示——这更接近Pygame的底层逻辑：

import numpy as np
import tkinter as tk
from PIL import Image, ImageTk
import time

root = tk.Tk()
size = (400,400)
canvas = tk.Canvas(root, width=size[0], height=size[1])
canvas.pack()

# 初始化图像对象
img = Image.new('RGB', size)
tk_img = ImageTk.PhotoImage(img)
canvas_img = canvas.create_image(0, 0, anchor=tk.NW, image=tk_img)

t0 = time.perf_counter()
count = 0

try:
    while count < 1000:
        # 生成随机像素数据并更新图像
        rand_data = np.random.randint(0, 256, size[0]*size[1]*3, dtype=np.uint8)
        img.frombytes(rand_data.tobytes())
        tk_img.paste(img)
        
        # 快速刷新画布
        canvas.update_idletasks()
        canvas.update()
        
        count += 1
finally:
    root.destroy()

print(f"帧率：{count/(time.perf_counter()-t0):.1f}帧/秒")

为什么你的原始Matplotlib代码帧率低？ #

你的代码里FuncAnimation的interval设为50ms（对应20帧/秒），而且每次更新都要重新计算f(x,y)并触发Matplotlib的上层渲染检查，这些额外逻辑大幅拖慢了速度。上面的方案直接跳过了这些流程，帧率能接近Pygame的水平。

内容的提问来源于stack exchange，提问作者B. M.