大家好!不知道你有没有过这样的经历:为了给别人讲解定积分的几何意义,你决定用 Manim 制作一个黎曼和(Riemann Sum)动画。

当你兴致勃勃地开始编码时,却发现要手写一堆循环来计算每个矩形的高度、宽度,还要处理复杂的积分上下限。

更头疼的是,当函数稍微复杂一点,比如 sin(x)*cos(x),手动计算理论面积几乎不可能。

别担心,今天我们继续来来分享:SymPy + Manim的绝妙组合。

把繁琐的数学计算交给 SymPy,专注于用 Manim 讲述精彩的故事!

1. 痛点场景还原

让我还原一个经典场景:你要做一个动画,展示 在 上的定积分,用黎曼和从粗糙到精细逼近真实面积。

传统做法是这样的:

1
2
3
4
5
6
7
8
9
10
11
# ❌ 传统手写黎曼和的痛苦代码
def riemann_sum(func, a, b, n):
dx = (b - a) / n
total = 0
rects = []
for i in range(n):
x = a + i * dx # 左端点
height = func(x) # 手动计算函数值
total += height * dx
# 还要手动创建矩形……
return total # 这个值对吗?天知道

问题在哪?

  • 精度依赖于 n:n=10 和 n=1000 结果差好远,到底哪个是对的?
  • **没有”标准答案”**:你不知道动画里的面积应该收敛到哪个数
  • 换函数成本高:从 换成 ?积分值要重新算

我真正需要的是一个能自动计算精确积分值、还能帮我生成数值数据的工具。

这时候,就该 SymPy 登场了。

2. SymPy 解决方案

SymPy 定积分:一行代码的事

SymPy 是 Python 的符号数学库,它能做精确的符号计算——不是数值近似,而是真正的解析解。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from sympy import symbols, integrate, sin, log, exp

x = symbols('x')

# 不定积分:返回原函数
indefinite = integrate(x**2, x)
print(f"不定积分: {indefinite}") # x**3/3

# 定积分:直接给精确值
definite = integrate(x**2, (x, 0, 2))
print(f"定积分: {definite}") # 8/3

# 复杂函数也毫无压力
result = integrate(log(x)/x, (x, 1, exp(1)))
print(f"复杂积分: {result}") # 1/2

看到了吗?SymPy 给了我们精确的分数或根号表达式,不是 2.6667 这种近似值。

这就是动画中那个”标准答案参考线”的最佳来源。

实战封装:一个积分计算工具箱

让我把常用的积分功能封装一下,方便在 Manim 中调用:

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
36
37
38
39
40
import sympy as sp

class IntegralHelper:
"""Manim 动画的积分计算助手"""

def __init__(self, func_str):
"""
参数:
func_str: 函数表达式字符串,如 'x**2', 'sin(x)'
"""
self.x = sp.symbols("x")
self.f_expr = sp.sympify(func_str) # 将字符串转为 SymPy 表达式
self.f_lambda = sp.lambdify(self.x, self.f_expr, "numpy") # 转为数值函数

def exact_integral(self, a, b):
"""计算定积分的精确值(分数/根号形式)"""
result = sp.integrate(self.f_expr, (self.x, a, b))
return result

def float_integral(self, a, b):
"""计算定积分的浮点数值"""
result = sp.integrate(self.f_expr, (self.x, a, b))
return float(result.evalf())

def riemann_sum(self, a, b, n, method="left"):
"""生成黎曼和的数据点(用于 Manim 动画)"""
dx = (b - a) / n
data = []
for i in range(n):
if method == "left":
xi = a + i * dx
elif method == "right":
xi = a + (i + 1) * dx
else: # midpoint
xi = a + (i + 0.5) * dx

height = float(self.f_lambda(xi))
data.append({"x": xi, "y": height, "width": dx, "area": height * dx})

return data

下载 Python 脚本

关键点解释:

  • sp.sympify() 把字符串变成符号表达式,用户只需要传 'x**2' 这样友好的格式
  • sp.lambdify() 把符号表达式变成 NumPy 函数,在 Manim 中可以快速求值
  • riemann_sum() 方法直接输出矩形的位置和高度数据,Manim 直接用就好

3. Manim 联动实战:积分动画

光说不练假把式,来看看完整可运行的代码。这个动画会展示:

  1. 曲线 的图形
  2. 逐渐增多的黎曼和矩形
  3. 逐渐增多的矩形面积和
  4. 对比矩形面积和与积分的精确值
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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
from manim import *
import numpy as np
from numpy import array
run_time = 1
data = [[1, 2], [3, 4]]
def dot(pos, **kwargs):
return Dot(pos, **kwargs)
import sympy as sp
import numpy as np
class RiemannToIntegral(Scene):
def construct(self):
# ========== SymPy 符号积分部分 ==========
x_sym = sp.Symbol('x')
f_sym = x_sym**2 # 被积函数:f(x) = x²
f = sp.lambdify(x_sym, f_sym, "numpy") # 转为 NumPy 函数
a, b = 0, 2 # 积分区间 [0, 2]
# SymPy 自动求精确积分和原函数
exact_integral = sp.integrate(f_sym, (x_sym, a, b)) # ∫₀² x² dx = 8/3
F_sym = sp.integrate(f_sym, x_sym) # 原函数 F(x) = x³/3
# ========== Manim 坐标系与曲线 ==========
axes = Axes(
x_range=[-0.5, 2.5, 0.5], y_range=[-0.5, 5, 1],
x_length=6, y_length=5, axis_config={"color": BLUE}
)
curve = axes.plot(f, x_range=[a, b], color=YELLOW, stroke_width=3)
# ========== 黎曼和矩形生成函数 ==========
def get_riemann_rects(n):
"""生成 n 个右端点黎曼和矩形"""
dx = (b - a) / n # 每个矩形的宽度
rects = VGroup()
total_area = 0
for i in range(1, n + 1):
xi = a + i * dx # 右端点横坐标
yi = f(xi) # 矩形高度 f(xi)
area_i = yi * dx # 单个矩形面积
total_area += area_i
rect = Rectangle(
width=axes.x_length * dx / (b - a), # 缩放到屏幕宽度
height=axes.y_length * yi / 5, # 缩放到屏幕高度
fill_opacity=0.3, fill_color=BLUE,
stroke_color=BLUE_B, stroke_width=0.2,
).move_to(axes.c2p(xi - dx/2, yi/2)) # 左下角定位
rects.add(rect)
return rects, total_area
# ========== 动画流程:n 递增,矩形逼近曲线下面积 ==========
self.play(Create(axes), Create(curve))
current_rects = None
for n in [2, 4, 8, 16, 32]:
new_rects, area_sum = get_riemann_rects(n)
if current_rects is None:
self.play(Create(new_rects))
else:
self.play(ReplacementTransform(current_rects, new_rects))
current_rects = new_rects
self.wait(0.3)
# 展示精确积分值(SymPy 计算结果)
exact_val = float(exact_integral)
result_label = MathTex(
f"\\int_{{{a}}}^{{{b}}} x^2 \\,dx = \\frac{{8}}{{3}} \\approx {exact_val:.4f}",
color=GREEN, font_size=30
).to_edge(DOWN)
self.play(Write(result_label))
self.wait(2)

下载 Python 脚本

4. 效果展示:动画看起来什么样

当你运行这段代码,你会看到:

  1. 坐标轴和曲线出现:蓝色坐标轴,黄色抛物线
  2. 矩形演化:
    • 先是 2 个粗糙的蓝色矩形(误差巨大)
    • 然后变成 4 个、8 个、16 个、32 个
    • 矩形越来越细,顶部越来越贴合曲线
    • 屏幕下方实时显示当前黎曼和的数值
  3. 收敛之美:你会亲眼看到黎曼和从 5 到 3.75 再到 3.1875……逐渐逼近 2.7930
  4. 最终对比:绿色文字显示精确值与最后一次近似的误差,通常已经小到 0.2 以下

整个动画最妙的地方:如果你想把函数从 换成 ,只需要改一行:

1
f_expr = sp.sin(x)  # 就这一行!

SymPy 会自动重算积分、更新参考线、调整所有数值。这就是符号计算的力量。

5. 本期小结

今天我们解决了 Manim 动画中的一个核心痛点:数学计算的自动化。

痛点 SymPy 的解决方案
手动计算定积分值 integrate(f, (x, a, b)) 一行搞定
不知道黎曼和是否准确 用精确值作为”标准答案”参考线
换函数要重新手算 改函数表达式,其余自动更新
精度不可控 用 lambdify 生成高效数值函数

核心代码三件套:

  • sp.integrate() → 精确积分值(动画的”真理”)
  • sp.lambdify() → 高效数值函数(矩形高度、曲线绘制)
  • riemann_sum() 生成器 → 直接喂给 Manim 的 Rectangle