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

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

这个过程的核心是计算割线的斜率 ,并观察当 趋近于 0 时,这个斜率是如何变化的。

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

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

想象一下,我们要为函数 做一个在 处的切线动画。

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

如果手动来做,第2、3步就需要展开 ,再减去 ,化简,最后求极限。

对于复杂的函数,这简直是灾难!(比如函数 )

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

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

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

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

针对我们的需求,只需要两个核心函数:

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
from manim import *
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 点的位置和割线,从而实现动态效果。

下面是核心的代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
from manim import *
import numpy as np
import sympy as sp
def head(cn, en):
t = Text(cn, font="STLiti", font_size=27).to_edge(UP)
s = Text(en, font="Consolas", font_size=20, color=YELLOW).next_to(t, DOWN, buff=0.10)
return VGroup(t, s)
def foot(cn):
return Text(cn, font="STLiti", font_size=20, color=YELLOW).to_edge(DOWN)
class DerivativeTangent(Scene):
def construct(self):
self.add(head("导数:割线逼近切线", "SymPy / diff / ValueTracker"))
x = sp.symbols("x")
f = x**3 - 2*x + 1
df = sp.diff(f, x)
fy = sp.lambdify(x, f, "numpy")
slope = float(df.subs(x, 1))
y1 = float(f.subs(x, 1))
axes = Axes(x_range=[-2.5, 2.5, 1], y_range=[-3, 5, 1], x_length=8, y_length=5,
axis_config={"color": GREY_B}).shift(DOWN * 0.3)
graph = axes.plot(lambda t: fy(t), x_range=[-2.1, 2.1], color=BLUE).set_stroke(width=5)
h = ValueTracker(1.8)
sec = always_redraw(lambda: Line(
axes.c2p(1, y1),
axes.c2p(1 + h.get_value(), fy(1 + h.get_value())),
color=YELLOW).set_stroke(width=5))
tangent = Line(axes.c2p(-1.2, y1 + slope * (-2.2)),
axes.c2p(2.2, y1 + slope * 1.2), color=RED).set_stroke(width=5)
lab = Text("slope = %.2f" % slope, font="Consolas", font_size=22,
color=GREY_A).to_corner(UR)
self.add(axes, graph, sec, lab)
self.play(h.animate.set_value(0.18), run_time=3.4)
self.play(Create(tangent), run_time=1.4)
self.play(FadeIn(foot("h 趋近 0 时割线斜率收敛到导数值")), run_time=0.4)
self.wait(1.2)

下载 Python 脚本

代码关键点解析

  • 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. 坐标系与函数登场:黄色的三次函数 被绘制出来。
  2. 固定点 P:在处,一个红色的点 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 负责表现” 的模式非常强大,可以应用到各种复杂的数学可视化场景中。