大家好，你有没有试过在 Manim 里做导数定义的动画？

就是那个经典的场景：画一条曲线，再画一条割线，然后让割线上的一个点无限逼近另一个点，最后变成切线。

这个过程的核心是计算割线的斜率 (f(x+h) - f(x)) / h，并观察当 h 趋近于 0 时，这个斜率是如何变化的。

听起来很简单，但实际操作起来，手动去推导极限、计算每一帧的坐标，不仅繁琐，还特别容易出错。

相信不少朋友都为此头疼过。

想象一下，我们要为函数 $ f(x) = x^3 - 2x + 1 $ 做一个在 $ x=1 $ 处的切线动画。

1. 定义割线：我们需要两个点，$ P(1, f(1)) $ 和 $ Q(1+h, f(1+h)) $。
2. 计算斜率：$ slope = (f(1+h) - f(1)) / h $。
3. 求极限：为了让动画平滑过渡到切线，我们需要知道当 $ h \to 0 $ 时，$ slope $ 的精确值，也就是 $ f'(1) $。
4. 动态更新：在动画中，$ h $ 是一个不断变小的值（比如从 1 变到 0.01），我们需要为每一个 h 实时计算 Q 点的坐标和割线的斜率。

如果手动来做，第2、3步就需要展开 $ (1+h)^3 - 2(1+h) + 1 $，再减去 $ f(1) $，化简，最后求极限。

对于复杂的函数，这简直是灾难！（比如函数$ f(x)=sin(x^2) $）

而且，在代码里硬编码这些公式，一旦函数变了，所有计算都得重来。

这就是我们的痛点：动态、精准、自动化地处理符号计算。

SymPy 解决方案：让计算机做数学

SymPy 正是解决这个问题的完美工具，它可以把 x, h 当作真正的数学符号来处理，而不是具体的数字。

针对我们的需求，只需要两个核心函数：

• diff(f, x): 自动求导。直接告诉我们 f(x) 的导函数是什么。
• limit(expr, h, 0): 计算极限。可以验证我们的割线斜率在 h->0 时的确等于导数值。

下面看一段核心的 SymPy 代码，感受一下它的威力：

from sympy import symbols, diff, limit

# 定义符号变量
x = symbols('x')

# 定义我们的函数 f(x)
f = x**3 - 2*x + 1

# --- 核心操作 ---
# 自动求导，得到 f'(x)
f_prime = diff(f, x)
print(f"导函数 f'(x) = {f_prime}") 
# 输出: 导函数 f'(x) = 3*x**2 - 2

# 在 x=1 处的导数值
slope_at_1 = f_prime.subs(x, 1)
print(f"x=1 处的瞬时变化率 (斜率) = {slope_at_1}")
# 输出: x=1 处的瞬时变化率 (斜率) = 1

# 用极限来验证割线斜率
# 割线斜率表达式
secant_slope_expr = (f.subs(x, 1+h) - f.subs(x, 1)) / h
# 计算 h->0 时的极限
limit_slope = limit(secant_slope_expr, h, 0)
print(f"通过极限计算得到的斜率 = {limit_slope}")
# 输出: 通过极限计算得到的斜率 = 1

看！我们完全不用关心中间复杂的代数运算，SymPy 几行代码就帮我们完成了求导和极限验证，并且结果精确无误。

这为我们接下来的 Manim 动画提供了坚实的数学基础。

Manim 联动实战：让切线“动”起来

现在，我们将 SymPy 的计算能力嵌入到 Manim 动画中。

我们将使用 ValueTracker 来控制 h 的值，让它从一个较大的数（如1）逐渐减小到接近0。

在每一帧，Manim 都会调用 SymPy 重新计算 Q 点的位置和割线，从而实现动态效果。

下面是核心的代码：

from manim import *
from sympy import symbols, lambdify, diff

class DerivativeAnimation(Scene):
    def construct(self):
        # ========== SymPy 符号计算部分 ==========
        x_sym = symbols("x")
        f_sym = x_sym**3 - 2*x_sym + 1           # 原函数：f(x) = x³ - 2x + 1
        f = lambdify(x_sym, f_sym, "numpy")       # 转为 NumPy 函数供绘图

        f_prime_sym = diff(f_sym, x_sym)          # SymPy 自动求导：f'(x) = 3x² - 2
        x_p = 1                                    # 切点横坐标
        exact_k = float(f_prime_sym.subs(x_sym, x_p))  # 精确导数 f'(1) = 1

        # ========== Manim 坐标系与曲线 ==========
        ax = Axes(x_range=[-2, 3], y_range=[-3, 5])
        graph = ax.plot(f, color=YELLOW)          # 原函数曲线

        p_point = Dot(ax.c2p(x_p, f(x_p)), color=RED)  # 切点 P

        # ========== ValueTracker 驱动割线动态逼近 ==========
        h_tracker = ValueTracker(1)               # h 从 1 逐渐减小到 0.001

        # 割线：随 h 变化而重新绘制
        def get_secant_line():
            h_val = h_tracker.get_value()
            x_q = x_p + h_val
            k = (f(x_q) - f(x_p)) / h_val         # 割线斜率 Δy/Δx
            return ax.plot(
                lambda x: k * (x - x_p) + f(x_p), # 点斜式
                color=GREEN, x_range=[x_p - 1, x_q + 1]
            )

        secant_line = always_redraw(get_secant_line)

        # 切线：使用 SymPy 算出的精确导数
        tangent_line = ax.plot(
            lambda x: exact_k * (x - x_p) + f(x_p),
            color=PURPLE, x_range=[-0.5, 2.5]
        )

        # ========== 动画流程 ==========
        self.play(Create(ax), Create(graph), Create(p_point))
        self.play(Create(secant_line))

        # 核心：h → 0，割线动态逼近切线
        self.play(
            h_tracker.animate.set_value(0.001),
            run_time=5,
            rate_func=rate_functions.ease_in_out_quad,
        )

        # 对比展示精确切线
        self.play(Create(tangent_line))
        self.wait(1)

代码关键点解析

• lambdify: 连接 SymPy 和 Manim 的桥梁。它把 SymPy 的符号表达式 f_sym 转换成一个普通的 Python 函数 f，这个函数可以接受 NumPy 数组作为输入，正好符合 Manim ax.plot() 的要求。
• ValueTracker: Manim 中创建动态效果的核心。h_tracker 存储了 h 的当前值。
• always_redraw: 这个装饰器告诉 Manim，被它修饰的对象（如 q_point 和 secant_line）需要在每一帧都重新计算和绘制。它们内部的函数 get_q_point 和 get_secant_line 会读取 h_tracker 的最新值，并调用 f 函数来获取最新的坐标。
• 动态割线: 在 get_secant_line 中，我们虽然可以直接用两点式画线，但这里展示了如何利用 SymPy 的思想——通过计算斜率和截距来定义直线，逻辑更清晰。

效果展示说明

运行这段代码，你会看到以下动画效果：

1. 坐标系与函数登场：黄色的三次函数$ f(x)=x^3-2x+1 $被绘制出来。
2. 固定点 P：在$ x=1 $处，一个红色的点 P 被标记出来。
3. 动态点 Q 与割线：一个蓝色的点 Q 出现在 P 的右侧（因为初始 h=1），一条绿色的割线连接 P 和 Q。
4. 魔法时刻：动画开始，Q 点开始平滑地向 P 点移动（h 值从 1.5 逐渐减小到 0.01）。与此同时，绿色的割线也随之旋转。
5. 切线显现：当 Q 无限接近 P 时，割线几乎不再变化。此时，一条紫色的精确切线被绘制出来，你会发现它和最终的割线几乎完全重合！

整个过程直观地展示了导数作为瞬时变化率的几何意义，而这一切的精准性都由 SymPy 在幕后保证。

小结

我们已经成功地将 SymPy 的符号计算能力与 Manim 的动画渲染能力结合起来，解决了制作导数定义动画时的手动计算痛点。

通过 diff 和 limit，我们获得了精确的数学结果；

通过 ValueTracker 和 always_redraw，我们让这些结果在屏幕上“活”了起来。

这种 “SymPy 负责思考，Manim 负责表现” 的模式非常强大，可以应用到各种复杂的数学可视化场景中。