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

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

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

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

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

1. 痛点场景还原

让我还原一个经典场景：你要做一个动画，展示 $ f(x) = x^2 $ 在 $ [0, 2] $ 上的定积分，用黎曼和从粗糙到精细逼近真实面积。

传统做法是这样的：

# ❌ 传统手写黎曼和的痛苦代码
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 结果差好远，到底哪个是对的？
• 没有"标准答案"：你不知道动画里的面积应该收敛到哪个数
• 换函数成本高：从 $ x^2 $ 换成 $ \sin x $？积分值要重新算

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

这时候，就该 SymPy 登场了。

2. SymPy 解决方案

SymPy 定积分：一行代码的事

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

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 中调用：

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

关键点解释：

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

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

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

1. 曲线 $ f(x) = x^2 $ 的图形
2. 逐渐增多的 黎曼和矩形
3. 逐渐增多的 矩形面积和
4. 对比矩形面积和与积分的精确值

from manim import *
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)

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

当你运行这段代码，你会看到：

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

整个动画最妙的地方：如果你想把函数从 $ x^2 $ 换成 $ \sin x $，只需要改一行：

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

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

5. 本期小结

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

核心代码三件套：

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