大家好，今天要解决一个痛点是关于 因式分解公式 的。

直接说问题：
用 Manim 展示 $ x2 + 5x + 6 = (x+2)(x+3) $ 的“十字相乘”面积模型，你需要先想好怎样把大矩形拆成四块$ (x^2)、(2x)、(3x)、(6) $，再手动计算每一块的边长和位置。

换成 $ x^2 + 7x + 12 $，布局又要重新算。

有没有办法只告诉程序“我要做这个多项式因式分解的拼图证明”，它就能自动生成所有矩形的尺寸和坐标？

有，用 SymPy。

它能够根据代数式的结构自动推导几何布局，让你从“一个公式写一套代码”升级为“一类公式共用一套生成器”。

1. 痛点场景还原：公式一换，布局全乱

先看一个“传统”手动布局的例子。

我们想讲 $ x^2 + 5x + 6 = (x+2)(x+3) $ 的面积模型，把大矩形分成四块：

from manim import *

class ManualX2Plus5xPlus6(Scene):
    def construct(self):
        x = 2  # 让 x 取某个具体值来画图
        # 手动指定四块的宽高
        # 大矩形宽 (x+3)，高 (x+2)
        # 四块：x*x, 3*x, 2*x, 2*3
        sq_x2 = Rectangle(width=x, height=x, color=BLUE, fill_opacity=0.4)
        rec_3x = Rectangle(width=3, height=x, color=RED, fill_opacity=0.4)
        rec_2x = Rectangle(width=x, height=2, color=RED, fill_opacity=0.4)
        rec_6 = Rectangle(width=3, height=2, color=GREEN, fill_opacity=0.4)

        # 手动拼：左下角 sq_x2，右边 rec_3x，上边 rec_2x，右上 rec_6
        sq_x2.shift(LEFT * (3 / 2) + DOWN * (2 / 2))
        rec_3x.next_to(sq_x2, RIGHT, buff=0)
        rec_2x.next_to(sq_x2, UP, buff=0)
        rec_6.next_to(rec_3x, UP, buff=0)

        self.play(Create(sq_x2), Create(rec_3x), Create(rec_2x), Create(rec_6))
        self.wait(1)

要改成 $ x^2 + 7x + 12 = (x+3)(x+4) $，你需要改：

• 常数项 3 → 3、4；
• 矩形 rec_3x 的宽度 → 4；
• 矩形 rec_2x 的高度 → 3；
• 小矩形 rec_6 的宽高 → 4 和 3；
• shift 里面的偏移量也要跟着变。

每一次改公式都是一次手工劳动，而且容易出错。

如果公式结构稍微复杂一点（比如二次项系数不是 1，或者有三项展开），这种手动模式基本就难以维护了。

2. SymPy 解决方案：因式分解→几何布局

SymPy 的杀手锏就在这里：它可以对多项式进行因式分解或展开，自动抽取出每一项的系数和次数。

然后我们根据这些信息，自动生成对应的矩形拼图布局。

整体流程是：

1. 输入一个多项式字符串，如 "x**2 + 5*x + 6"；
2. 用 SymPy 对其进行因式分解，得到 (x + 2)*(x + 3)；
3. 从因式结果中读出两个一次式的常数项（2 和 3），从展开式中读出各项系数（1, 5, 6）；
4. 自动生成四个矩形块：$ x^2 $（边长 $ x \(）、\) 2x $（宽 2 高 $ x \(）、\) 3x $（宽 $ x $ 高 3）、6（宽 2 高 3），并根据这些边长自动算出左下角坐标；
5. 将布局信息输出为一个统一的数据结构，供 Manim 使用。

这样，无论你输入 $ x^2 + 7x + 12 $ 还是 $ x^2 - 3x + 2 $，甚至带参数的 $ x^2 + (a+b)x + ab $，布局生成逻辑都完全一样——你只需要换一个多项式字符串。

下面是一段纯 SymPy 的布局生成器代码，不依赖 Manim，可以直接在 Jupyter 里跑：

from sympy import symbols, factor, expand, Poly
from sympy.abc import x

def generate_layout(poly_expr):
    """
    输入：一个关于 x 的多项式（可因式分解为 (x+a)(x+b)）
    输出：四个矩形的布局信息列表，每个矩形包括 (标签, 宽, 高, x坐标, y坐标)
    """
    # 因式分解
    factored = factor(poly_expr)            # 例如 (x + 2)*(x + 3)
    # 确保是两个一次因式
    if not factored.is_Mul:
        raise ValueError("多项式不能分解为两个一次因式")
    factors = factored.args
    if len(factors) != 2:
        raise ValueError("暂时只支持两个一次因式")

    # 提取常数项 a, b
    a = None
    b = None
    for fac in factors:
        if fac.is_Add:
            # 形如 x + c，提取常数 c
            coeff_dict = Poly(fac, x).as_dict()
            c = -coeff_dict.get(0, 0) if 1 in coeff_dict and coeff_dict[1]==1 else None
            # 这里做一个简单处理：假定就是 x - a 形式
            # 我们用 Poly 提取根
            p = Poly(fac, x)
            if p.degree() == 1:
                root = -p.coeff_monomial(1) / p.coeff_monomial(0)  # 其实标准形式是 x - r
                # 更稳健：fac = x + a0 => a0
                const = p.coeff_monomial(1)  # 系数 1
                const_term = p.coeff_monomial(0)  # a0
                if const == 1:
                    val = const_term
                else:
                    val = const_term / const
            if a is None:
                a = val
            else:
                b = val

    # 展开式获取各项
    expanded = expand(poly_expr)
    poly = Poly(expanded, x)
    coeff_x2 = poly.coeff_monomial(2)  # x^2 系数
    coeff_x  = poly.coeff_monomial(1)  # x 系数
    const    = poly.coeff_monomial(0)  # 常数项

    # 现在已知大矩形的宽 = (x + a)，高 = (x + b)，但我们是取具体 x 值画图
    # 这里的布局用符号 a, b 表达（注意 a,b 是常数数值，不是符号）
    # 返回布局，宽和高用数值表达式（含 x），留给 Manim 代入 x_val
    layout = [
        {"label": "x^2", "w": "x", "h": "x", "x0": 0, "y0": 0},
        {"label": f"{b}x", "w": b, "h": "x", "x0": "x", "y0": 0},
        {"label": f"{a}x", "w": "x", "h": a, "x0": 0, "y0": "x"},
        {"label": f"{a*b}", "w": b, "h": a, "x0": "x", "y0": "x"},
    ]
    return layout, a, b

# 示例：x^2 + 5x + 6
layout, a, b = generate_layout(x**2 + 5*x + 6)
print("a =", a, " b =", b)
for item in layout:
    print(item)

输出：

a = 2  b = 3
{'label': 'x^2', 'w': 'x', 'h': 'x', 'x0': 0, 'y0': 0}
{'label': '3x', 'w': 3, 'h': 'x', 'x0': 'x', 'y0': 0}
{'label': '2x', 'w': 'x', 'h': 2, 'x0': 0, 'y0': 'x'}
{'label': '6', 'w': 3, 'h': 2, 'x0': 'x', 'y0': 'x'}

可以看到，矩形的宽高和坐标全部由 a 和 b 决定，而 a,b 是从 SymPy 因式分解中自动提取的。换一个多项式，只需改一行输入，布局自动生成。

3. Manim 联动实战：通用因式分解拼图动画

现在我们把这个自动布局引擎接入 Manim，做一个通用场景：你只需要在开头指定多项式，动画就会自动展示对应的面积拼图，并标注公式。

代码如下：

from manim import *
from sympy import factor, Poly
from sympy.abc import x

class AutoFactorPuzzle(Scene):
    def construct(self):
        # ========== 1. 在这里输入你要讲的多项式 ==========
        poly_expr = x**2 + 5 * x + 6  # 试着改成 x**2 + 7*x + 12 看看！
        x_val = 1.5  # 动画中 x 的具体取值（可调）

        # ========== 2. SymPy 自动分析多项式 ==========
        factored = factor(poly_expr)
        if not factored.is_Mul or len(factored.args) != 2:
            raise ValueError("多项式需能分解为两个一次因式 (x+a)(x+b)")
        # 提取 a, b
        roots = []
        for fac in factored.args:
            p = Poly(fac, x)
            if p.degree() != 1:
                raise ValueError("因式必须是一次式")
            # 一次多项式 ax + b，all_coeffs() 返回 [a, b]
            coeffs = p.all_coeffs()
            # 根为 -b/a
            root = -coeffs[1] / coeffs[0]
            roots.append(root)
        a, b = float(roots[0]), float(roots[1])  # 常数项 a, b

        # ========== 3. 根据 a, b 生成矩形布局 ==========
        # 四个矩形：x^2, b*x, a*x, a*b
        blocks = [
            {"label": "x^2", "w": x_val, "h": x_val, "x0": 0, "y0": 0, "color": BLUE},
            {
                "label": f"{abs(b)} \\times x",
                "w": abs(b),
                "h": x_val,
                "x0": x_val,
                "y0": 0,
                "color": RED,
            },
            {
                "label": f"{abs(a)} \\times x",
                "w": x_val,
                "h": abs(a),
                "x0": 0,
                "y0": x_val,
                "color": YELLOW,
            },
            {
                "label": f"{abs(b)} \\times {abs(a)}",
                "w": abs(b),
                "h": abs(a),
                "x0": x_val,
                "y0": x_val,
                "color": GREEN,
            },
        ]

        # ========== 4. Manim 绘制 ==========
        # 创建四个内部矩形
        for blk in blocks:
            rect = Rectangle(
                width=blk["w"],
                height=blk["h"],
                color=blk["color"],
                fill_opacity=0.4,
                stroke_width=1,
            )
            # 左下角坐标转换为 Manim 中心坐标
            rect.move_to([blk["x0"] + blk["w"] / 2, blk["y0"] + blk["h"] / 2, 0])

            # 偏移一个固定位置
            rect.shift(LEFT * 2 + DOWN)

            label = MathTex(f"{blk['label']}", font_size=16)
            label.move_to(rect.get_center())
            self.play(Create(rect), Write(label))

        self.wait(0.5)

        # 显示等式
        eq = MathTex(
            f"{{x}}^2 + {poly_expr.coeff(x,1)}x + {poly_expr.coeff(x,0)}",
            "=",
            f"(x{a if a<0 else abs(a)})(x{b if b<0 else abs(b)})",
            font_size=20,
        ).shift(DOWN * 1.5)
        self.play(Write(eq))
        self.wait(2)

关键解释：

• 多形式输入只改 poly_expr = ... 一行，整段代码就能绘制出对应的十字相乘面积图；
• SymPy 的 factor 自动拆出一次因式，Poly 帮我们提取系数，a 和 b 直接成为矩形的边长参数；
• 整个布局的坐标逻辑只写了一次，通过 a、b、x_val 计算出 blocks，没有手动偏移。

试一下把 poly_expr 改成 x**2 + 7*x + 12，重新运行，动画将立刻变成 $ x^2 \(（蓝）、\) 4x \(（红）、\) 3x \(（黄）、\) 12 $（绿）的四块拼图，等式也变为 $ x^2+7x+12=(x+4)(x+3) $。

4. 效果展示说明

运行上面的 AutoFactorPuzzle，你会看到：

1. 内部四块矩形依次浮现：蓝色 $ x^2 $ 在左下，右侧是一块红色 $ bx $，上方是一块 黄色 $ ax $，右上角是绿色常数块 $ ab $。所有块之间严丝合缝，因为它们的坐标和边长都来自同一个因式分解结果。
2. 标签 $ x^2 \(、\) bx \(、\) ax \(、\) ab $ 精准居中，清晰对应代数项。
3. 下方显示因式分解的等式，左边是展开式，右边是因式乘积，学生可以立刻将图形与公式对应起来。

更重要的是：换一个多项式只需要改一行代码，动画逻辑完全复用。

想一次性展示多个公式的对比？只需要建几个不同的场景实例即可。

这让“制作一套完整的因式分解几何证明微课”从一天的工作量缩短到一小时。

5. 小结

SymPy 在这个场景中扮演的角色，是一个代数结构的自动解析器。

传统方法也能拼出图，但你得用大脑去“解析”公式，再手动翻译成矩形的宽高和位置；

而 SymPy 帮你自动完成“因式分解 → 提取系数 → 生成几何参数”的全过程，让你专注于教学设计和动画美化。

这个模式可以轻松扩展到：

• 二次三项式的十字相乘面积模型（即本文的例子）；
• 完全平方和平方差公式的拼图证明；
• 多项式乘法的面积表示（如 $ (x+a)(x+b)(x+c) $ 的体积模型）；
• 甚至更复杂的恒等式，只要你能把代数结构映射为空间分割。