切线的邪术：用 SymPy 和 Manim 轻松搞定导数动画

各人好，你有没有试过在 Manim 里做导数界说的动画？
就是谁人经典的场景：画一条曲线，再画一条割线，然后让割线上的一个点无穷逼近另一个点，末了变成切线。
这个过程的核心是盘算割线的斜率 (f(x+h) - f(x)) / h，并观察当 h 趋近于 0 时，这个斜率是怎样厘革的。
听起来很简单，但实际利用起来，手动去推导极限、盘算每一帧的坐标，不但繁琐，还特别轻易堕落。
信赖不少朋侪都为此头疼过。
想象一下，我们要为函数 $ f(x) = x^3 - 2x + 1 $ 做一个在 $ x=1 $ 处的切线动画。

• 界说割线：我们须要两个点，$ P(1, f(1)) $ 和 $ Q(1+h, f(1+h)) $。
  
• 盘算斜率：$ slope = (f(1+h) - f(1)) / h $。
  
• 求极限：为了让动画平滑过渡到切线，我们须要知道当 $ h \to 0 $ 时，$ slope $ 的准确值，也就是 $ f'(1) $。
  
• 动态更新：在动画中，$ 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 代码，感受一下它的威力：

1. from sympy import symbols, diff, limit
3. # 定义符号变量
4. x = symbols('x')
6. # 定义我们的函数 f(x)
7. f = x**3 - 2*x + 1
9. # --- 核心操作 ---
10. # 自动求导，得到 f'(x)
11. f_prime = diff(f, x)
12. print(f"导函数 f'(x) = {f_prime}")
13. # 输出: 导函数 f'(x) = 3*x**2 - 2
15. # 在 x=1 处的导数值
16. slope_at_1 = f_prime.subs(x, 1)
17. print(f"x=1 处的瞬时变化率 (斜率) = {slope_at_1}")
18. # 输出: x=1 处的瞬时变化率 (斜率) = 1
20. # 用极限来验证割线斜率
21. # 割线斜率表达式
22. secant_slope_expr = (f.subs(x, 1+h) - f.subs(x, 1)) / h
23. # 计算 h->0 时的极限
24. limit_slope = limit(secant_slope_expr, h, 0)
25. print(f"通过极限计算得到的斜率 = {limit_slope}")
26. # 输出: 通过极限计算得到的斜率 = 1

复制代码

看！我们完全不消关心中心复杂的代数运算，SymPy 几行代码就帮我们完成了求导和极限验证，而且效果准确无误。
这为我们接下来的 Manim 动画提供了坚固的数学底子。
Manim 联动实战：让切线“动”起来

如今，我们将 SymPy 的盘算本事嵌入到 Manim 动画中。
我们将利用 ValueTracker 来控制 h 的值，让它从一个较大的数（如1）渐渐减小到靠近0。
在每一帧，Manim 都会调用 SymPy 重新盘算 Q 点的位置和割线，从而实现动态效果。
下面是核心的代码：

1. from manim import *
2. from sympy import symbols, lambdify, diff
4. class DerivativeAnimation(Scene):
5.     def construct(self):
6.         # ========== SymPy 符号计算部分 ==========
7.         x_sym = symbols("x")
8.         f_sym = x_sym**3 - 2*x_sym + 1           # 原函数：f(x) = x³ - 2x + 1
9.         f = lambdify(x_sym, f_sym, "numpy")       # 转为 NumPy 函数供绘图
11.         f_prime_sym = diff(f_sym, x_sym)          # SymPy 自动求导：f'(x) = 3x² - 2
12.         x_p = 1                                    # 切点横坐标
13.         exact_k = float(f_prime_sym.subs(x_sym, x_p))  # 精确导数 f'(1) = 1
15.         # ========== Manim 坐标系与曲线 ==========
16.         ax = Axes(x_range=[-2, 3], y_range=[-3, 5])
17.         graph = ax.plot(f, color=YELLOW)          # 原函数曲线
19.         p_point = Dot(ax.c2p(x_p, f(x_p)), color=RED)  # 切点 P
21.         # ========== ValueTracker 驱动割线动态逼近 ==========
22.         h_tracker = ValueTracker(1)               # h 从 1 逐渐减小到 0.001
24.         # 割线：随 h 变化而重新绘制
25.         def get_secant_line():
26.             h_val = h_tracker.get_value()
27.             x_q = x_p + h_val
28.             k = (f(x_q) - f(x_p)) / h_val         # 割线斜率 Δy/Δx
29.             return ax.plot(
30.                 lambda x: k * (x - x_p) + f(x_p), # 点斜式
31.                 color=GREEN, x_range=[x_p - 1, x_q + 1]
32.             )
34.         secant_line = always_redraw(get_secant_line)
36.         # 切线：使用 SymPy 算出的精确导数
37.         tangent_line = ax.plot(
38.             lambda x: exact_k * (x - x_p) + f(x_p),
39.             color=PURPLE, x_range=[-0.5, 2.5]
40.         )
42.         # ========== 动画流程 ==========
43.         self.play(Create(ax), Create(graph), Create(p_point))
44.         self.play(Create(secant_line))
46.         # 核心：h → 0，割线动态逼近切线
47.         self.play(
48.             h_tracker.animate.set_value(0.001),
49.             run_time=5,
50.             rate_func=rate_functions.ease_in_out_quad,
51.         )
53.         # 对比展示精确切线
54.         self.play(Create(tangent_line))
55.         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 的头脑——通过盘算斜率和截距来界说直线，逻辑更清楚。
  

效果展示阐明

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

• 坐标系与函数登场：黄色的三次函数$ f(x)=x^3-2x+1 $被绘制出来。
  
• 固定点 P：在$ x=1 $处，一个赤色的点 P 被标志出来。
  
• 动态点 Q 与割线：一个蓝色的点 Q 出如今 P 的右侧（由于初始 h=1），一条绿色的割线毗连 P 和 Q。
  
• 邪术时间：动画开始，Q 点开始平滑地向 P 点移动（h 值从 1.5 渐渐减小到 0.01）。与此同时，绿色的割线也随之旋转。
  
• 切线显现：当 Q 无穷靠近 P 时，割线险些不再厘革。此时，一条紫色的准确切线被绘制出来，你会发现它和终极的割线险些完全重合！
  

整个过程直观地展示了导数作为瞬时厘革率的多少意义，而这齐备的精准性都由 SymPy 在幕后包管。

小结

我们已经乐成地将 SymPy 的符号盘算本事与 Manim 的动画渲染本事联合起来，办理了制作导数界说动画时的手动盘算痛点。
通过 diff 和 limit，我们得到了准确的数学效果；
通过 ValueTracker 和 always_redraw，我们让这些效果在屏幕上“活”了起来。
这种 “SymPy 负责思考，Manim 负责体现” 的模式非常强大，可以应用到各种复杂的数学可视化场景中。

免责声明：如果侵犯了您的权益，请联系站长及时删除侵权内容，谢谢合作！qidao123.com:ToB企服之家，中国第一个企服评测及软件市场,开放入驻,技术点评得现金.