如何在低资源消耗下实现Mandelbrot集连续缩放并优化生成速度？

我正在开发Mandelbrot集可视化程序，现有代码如下：

import numpy as np
import matplotlib.pyplot as plt

plt.rcParams['toolbar'] = 'None'

def mandelbrot(c, max_iter):
    z = 0
    for n in range(max_iter):
        if abs(z) > 2:
            return n
        z = z*z + c
    return max_iter

def mandelbrot_set(xmin, xmax, ymin, ymax, width, height, max_iter):
    r1 = np.linspace(xmin, xmax, width)
    r2 = np.linspace(ymin, ymax, height)
    n3 = np.empty((width, height))

    for i in range(width):
        for j in range(height):
            n3[i, j] = mandelbrot(r1[i] + 1j*r2[j], max_iter)
    return n3.T

# Settings
xmin, xmax, ymin, ymax = -2.0, 1.0, -1.5, 1.5
width, height = 800, 800
max_iter = 256

# Generate Mandelbrot set
mandelbrot_image = mandelbrot_set(xmin, xmax, ymin, ymax, width, height, max_iter)

# Window
fig = plt.figure(figsize=(5, 5))
fig.canvas.manager.set_window_title('Mandelbrot Set')
ax = fig.add_axes([0, 0, 1, 1])   # Fill the whole window
ax.set_axis_off()

# Show fractal
ax.imshow(mandelbrot_image, extent=(xmin, xmax, ymin, ymax), cmap='hot')
plt.show()

目前在中端笔记本上生成该分形耗时较长，请问如何实现该分形的连续缩放，同时避免占用过多系统资源？有没有更快的实现缩放功能的方法？

一、先解决生成速度慢的核心问题 #

你的代码性能瓶颈在于双重Python循环，Python解释器处理循环的效率远低于编译型语言，下面是两种立竿见影的优化方式：

1. 用Numba JIT编译加速 #

Numba可以把Python函数编译成机器码，直接绕过Python解释器的开销，对循环密集型代码提升非常明显。

安装Numba：pip install numba

修改后的代码：

import numpy as np
import matplotlib.pyplot as plt
from numba import njit

plt.rcParams['toolbar'] = 'None'

# 用njit装饰器编译函数，禁用Python对象模式以获得最大速度
@njit
def mandelbrot(c, max_iter):
    z = 0
    for n in range(max_iter):
        if abs(z) > 2:
            return n
        z = z*z + c
    return max_iter

@njit
def mandelbrot_set(xmin, xmax, ymin, ymax, width, height, max_iter):
    r1 = np.linspace(xmin, xmax, width)
    r2 = np.linspace(ymin, ymax, height)
    n3 = np.empty((width, height))

    for i in range(width):
        for j in range(height):
            n3[i, j] = mandelbrot(r1[i] + 1j*r2[j], max_iter)
    return n3.T

# 后续代码不变...

这个修改能让生成速度提升10-50倍，具体取决于你的CPU。

2. 全向量化NumPy实现 #

完全抛弃Python循环，用NumPy的数组操作批量计算，利用底层C实现的并行性：

def mandelbrot_set_vectorized(xmin, xmax, ymin, ymax, width, height, max_iter):
    x = np.linspace(xmin, xmax, width)
    y = np.linspace(ymin, ymax, height)
    c = x[:, None] + 1j * y[None, :]
    z = np.zeros_like(c)
    iteration = np.zeros(c.shape, dtype=int)
    mask = np.ones(c.shape, dtype=bool)

    for n in range(max_iter):
        z[mask] = z[mask] ** 2 + c[mask]
        # 标记超出阈值的点，不再参与后续计算
        new_mask = abs(z) <= 2
        iteration[mask & ~new_mask] = n
        mask = new_mask
        if not np.any(mask):
            break
    iteration[mask] = max_iter
    return iteration

这种方式的速度和Numba接近，且不需要额外安装库。

二、实现高效的连续缩放功能 #

要实现缩放且不占用过多资源，核心思路是只计算缩放后的目标区域，而非整个分形，同时配合交互事件和渐进式渲染提升体验：

1. 基于Matplotlib事件的交互缩放 #

监听鼠标的点击/拖拽事件，确定缩放的区域，然后重新计算该区域的分形并更新图像：

import numpy as np
import matplotlib.pyplot as plt
from numba import njit

plt.rcParams['toolbar'] = 'None'

@njit
def mandelbrot(c, max_iter):
    z = 0
    for n in range(max_iter):
        if abs(z) > 2:
            return n
        z = z*z + c
    return max_iter

@njit
def mandelbrot_set(xmin, xmax, ymin, ymax, width, height, max_iter):
    r1 = np.linspace(xmin, xmax, width)
    r2 = np.linspace(ymin, ymax, height)
    n3 = np.empty((width, height))
    for i in range(width):
        for j in range(height):
            n3[i, j] = mandelbrot(r1[i] + 1j*r2[j], max_iter)
    return n3.T

# 全局变量存储当前视图参数
current_xmin, current_xmax = -2.0, 1.0
current_ymin, current_ymax = -1.5, 1.5
width, height = 800, 800
max_iter = 256

fig = plt.figure(figsize=(5, 5))
fig.canvas.manager.set_window_title('Mandelbrot Set')
ax = fig.add_axes([0, 0, 1, 1])
ax.set_axis_off()

# 初始渲染
img = ax.imshow(mandelbrot_set(current_xmin, current_xmax, current_ymin, current_ymax, width, height, max_iter),
                extent=(current_xmin, current_xmax, current_ymin, current_ymax),
                cmap='hot')

def on_mouse_press(event):
    global current_xmin, current_xmax, current_ymin, current_ymax
    if event.button == 1:  # 左键点击放大
        # 获取点击点的坐标
        x, y = event.xdata, event.ydata
        # 计算缩放后的区域（缩放到原来的1/2）
        dx = (current_xmax - current_xmin) / 4
        dy = (current_ymax - current_ymin) / 4
        current_xmin, current_xmax = x - dx, x + dx
        current_ymin, current_ymax = y - dy, y + dy
        # 重新计算并更新图像
        new_data = mandelbrot_set(current_xmin, current_xmax, current_ymin, current_ymax, width, height, max_iter)
        img.set_data(new_data)
        img.set_extent((current_xmin, current_xmax, current_ymin, current_ymax))
        fig.canvas.draw_idle()
    elif event.button == 3:  # 右键点击缩小
        dx = (current_xmax - current_xmin)
        dy = (current_ymax - current_ymin)
        x_center = (current_xmin + current_xmax) / 2
        y_center = (current_ymin + current_ymax) / 2
        current_xmin, current_xmax = x_center - dx, x_center + dx
        current_ymin, current_ymax = y_center - dy, y_center + dy
        new_data = mandelbrot_set(current_xmin, current_xmax, current_ymin, current_ymax, width, height, max_iter)
        img.set_data(new_data)
        img.set_extent((current_xmin, current_xmax, current_ymin, current_ymax))
        fig.canvas.draw_idle()

# 绑定鼠标点击事件
fig.canvas.mpl_connect('button_press_event', on_mouse_press)

plt.show()

2. 进一步优化资源占用的技巧 #

• 渐进式渲染：缩放时先以低分辨率（比如200x200）快速生成预览图，后台再计算高分辨率图像并替换，避免用户长时间等待。
• 迭代次数自适应：缩放越深的区域，需要的迭代次数越多，可以根据当前缩放级别动态调整max_iter，比如初始用256，放大到一定程度后增加到512、1024，平衡速度和细节。
• 缓存机制：对于已经计算过的区域，保存其坐标范围和计算结果，当缩放操作涉及到重叠区域时，直接复用缓存，减少重复计算。

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