多项式与有理函数：微积分预备的核心与Python验证

理解多项式与有理函数，是正式学习微积分之前最容易被低估的一块内容。微积分课本第一章往往从极限开始，但真正的计算对象，尤其在前半段课程里，绝大多数都是多项式、幂函数和由它们做商得到的有理函数。更实际的问题是：很多工程场景中，任意光滑函数都会被泰勒展开为多项式，控制系统里的传递函数也是有理函数。接下来的内容会围绕一条主线展开：先梳理多项式与有理函数的核心概念和标准运算，再讲部分分式这个微积分前最有用的技巧，最后把极限、导数、积分里常见的处理方式用可复现的 Python 代码验证一遍。

这篇文章的定位是“微积分预备”，偏重动手验证而不是纯推导。你会看到许多数学结论最后都落到一段短代码上，把你手算时容易犯的符号错误、约分不彻底、分解不彻底的问题提前暴露出来。

1. 为什么微积分预备阶段要先过多项式与有理函数

1.1 微积分课堂上最先遇到的函数对象

微积分第一课讲极限时，例子大多是“把某个 x 代入多项式，看看函数值趋向哪里”；讲导数时，第一个公式来自幂函数y = x^n；讲积分时，最初能直接算出来的也是多项式积分。也就是说，你并不需要先学完所有函数类型再进入微积分，但你的计算基本功必须足以应付两类对象：

• 多项式：f(x) = a_n x^n + a_{n-1} x^{n-1} + ... + a_1 x + a_0。
• 有理函数：两个多项式做商，R(x) = P(x) / Q(x)，其中Q(x) != 0。

理解这两类函数，能帮助你提前建立两个关键直觉。第一，多项式在实数轴上每一处都有定义，图像连续、光滑、没有断点，所以求极限时绝大多数地方可以直接代入。第二，有理函数本质上是“分式”，它天然自带分母为零的讨论，这也是微积分里间断点、渐近线、未定式 0/0 的雏形。预备阶段的重点不是把所有理论证明补完，而是把“看到函数能判断它属于哪一类，知道这一类该用什么方法处理”这个反应链建立起来。

1.2 工程里为什么到处是多项式和有理函数

从工程计算角度看，多项式几乎是所有更复杂函数的“计算代名词”。计算机做三角函数、指数函数、对数函数时，底层也不是真的去查函数表，而是用泰勒展开或切比雪夫近似把它们换算成多项式再进行求值。换句话说，多项式是数值计算的通用接口。

有理函数则在控制系统、信号处理和电路分析里高频出现。一个系统的传递函数经常写成两个多项式之比：

• 分子多项式决定系统的零点，分母多项式决定系统的极点。
• 极点位置直接决定系统是否稳定。
• 对传递函数做拉普拉斯反演时，又需要把它拆成部分分式，再逐项反变换。

所以，高中阶段觉得“多项式分解因式到底有什么用”的疑问，会在预备微积分和后续专业课上得到充分回答。现在把多项式乘除、因式分解、有理函数约分练熟，后面用到时就不会被计算细节绊住。

2. 多项式的结构、运算与 Python 验证

2.1 标准形式、次数、零点与因式定理

先明确标准记号。一个次数为n的多项式写成：

f(x) = a_n x^n + a_{n-1} x^{n-1} + ... + a_1 x + a_0

要求a_n != 0。这里有几个基础概念，后面全部要用：

因式定理说的是：x = c是f(x)的零点，等价于x - c能整除f(x)。这条定理的价值在于，它把“求根”和“因式分解”两件事直接绑在一起。你只要能找出一个零点，就能从原多项式中提出一个一次因式，把次数下降，逐步化成多个低次因式乘积。

微积分预备阶段最常用的因式分解场景是求极限。例如：

lim(x->1) (x^2 - 1) / (x - 1) = lim(x->1) (x - 1)(x + 1) / (x - 1) = 2

如果不先因式分解，分子分母都趋向 0，会得到无意义的 0/0；因式分解后约去公共因子，再用代入法就得到极限值。这类题目在微积分第一章反复出现，因式分解速度直接决定解题速度。

2.2 综合除法：既求值又可做多项式除法

多项式长除法能判断整除关系，也能把假分式转换为“多项式 + 余式”。手工做长除法很直观，但代码和数值计算里更喜欢综合除法，也叫霍纳法。它的核心思路是：计算a_n x^n + ... + a_0在某个具体点x_0的值时，不直接求高次幂，而是反复做“乘一次，加一次”：

result = a_n result = result * x_0 + a_{n-1} result = result * x_0 + a_{n-2} ... result = result * x_0 + a_0

写成 Python：

def horner(coeffs, x_val): result = coeffs[0] for c in coeffs[1:]: result = result * x_val + c return result # 求 2x^3 - 6x^2 + 2x - 1 在 x = 2 处的值 coeffs = [2, -6, 2, -1] print(horner(coeffs, 2))

输出是7。这种方法比直接写成2 * 2**3 - 6 * 2**2 + 2 * 2 - 1更稳定，因为高次幂计算会放大舍入误差，而霍纳法只有乘法和加法，误差积累更小。工程库里的np.polyval、np.polynomial.polynomial.polyval也基于类似思路。

综合除法还可以用来做多项式除法。手工场景下，先把除以一次式x - c的系数逐层带下来；代码场景下，sympy.div更直接：

import sympy as sp x = sp.symbols('x') numerator = x**3 - 1 denominator = x - 1 q, r = sp.div(numerator, denominator, x) print(q) # x**2 + x + 1 print(r) # 0

q是商式，r是余式。余式为 0，说明x - 1是x^3 - 1的因式，这正好验证因式定理。

2.3 用 SymPy 和 NumPy 做验证性计算

学习阶段最怕的是“手算错了还不知道”。用符号计算工具验证是一个非常稳妥的做法。SymPy 适合做符号层面的展开、分解、求解，NumPy 适合做数值层面的求值和求根。

先看 SymPy 的基本操作：

import sympy as sp x = sp.symbols('x') f = 2*x**3 - 6*x**2 + 2*x - 1 p = sp.Poly(f, x) print(p.degree()) # 3 print(p.coeffs()) # [2, -6, 2, -1] g = x**2 - 5*x + 6 print(sp.factor(g)) # (x - 2)*(x - 3) print(sp.solve(g, x)) # [2, 3]

Poly会把表达式整理成标准形式，拿到次数和系数列表；factor做因式分解；solve解方程。三者组合起来，可以快速验证你的手算结果。

再看 NumPy 的数值求根：

import numpy as np coeffs = [1, -5, 6] # x^2 - 5x + 6 print(np.roots(coeffs)) # array([3., 2.])

这里的系数顺序是从高次到低次，np.roots返回所有根。要注意，数值求根依赖浮点运算，根之间距离过近或多项式阶数过高时，结果可能有误差。符号计算和数值计算互相印证，是最稳妥的学习方式。

3. 有理函数的核心结构与部分分式

3.1 有理函数的定义域、约分与不可约性

有理函数形如：

R(x) = P(x) / Q(x)

其中P(x)和Q(x)都是多项式，且Q(x)不是零多项式。定义域是排除掉Q(x) = 0的所有实数点。也就是说，有理函数的图像天然在分母零点处断开或走向无穷。

处理有理函数时，第一件事是判断能不能约分。例如：

R(x) = (x^2 - 1) / (x - 1)

分子可以分解为(x - 1)(x + 1)，分母是x - 1，约分后得到x + 1。但要特别注意，约分前后的定义域不同：原始函数在x = 1处没有定义，化简后的x + 1在x = 1处有定义。数学上这叫“可去奇点”，因为通过补充定义可以让函数变得连续。

在微积分里，判断极限是否存在、能否约分，是处理 0/0 未定式的关键。在工程计算里，约分和定义域问题同样重要：如果你用化简后的表达式去计算原本不存在的点，就可能在逻辑上出错。因此，每次做有理函数约分，都要记录分母什么时候为零。

3.2 真分式、假分式和部分分式展开的意图

如果分子多项式的次数小于分母多项式的次数，称它为真分式；如果分子次数大于或等于分母次数，称它为假分式。假分式可以先做多项式除法，化成一个多项式加一个真分式：

R(x) = Q(x) + P_rem(x) / Q_den(x)

例如：

(x^3 + 1) / (x^2 - 1)

分子次数是 3，分母次数是 2，可以先做除法得到x加一个余式，再继续处理。

部分分式展开的目标，是把一个复杂真分式拆成几个更简单分式之和。为什么微积分预备阶段一定要掌握这个技巧？因为积分时，像1/(x - a)这样的简单分式，积分结果是ln|x - a| + C；而一个复杂分式的积分往往很难直接写出来。如果先拆成简单分式，再逐项积分，问题就被拆解成若干个已知结果的和。

不同类型的分解形式遵循以下原则：

真实场景中，绝大多数练习只考单重线性因式和简单二次式，但理解重因式的形式有助于你不知道下一步该设什么形状时，能猜出待定系数的结构。

3.3 用 apart 完成部分分式分解

SymPy 提供apart函数直接做部分分式展开。先看最简单的例子：

import sympy as sp x = sp.symbols('x') r1 = (2*x + 1) / ((x - 1)*(x + 2)) print(sp.apart(r1, x))

输出为：

1/(x + 2) + 1/(x - 1)

这等价于手算时设：

(2x + 1) / ((x - 1)(x + 2)) = A/(x - 1) + B/(x + 2)

解得A = 1、B = 1。apart完成了待定系数法的全部计算，你可以拿它对自己的手算结果做校验。

再看假分式场景：

r2 = (x**3 + 1) / (x**2 - 1) print(sp.apart(sp.cancel(r2), x))

输出为：

x + 1/(x - 1)

这里cancel先做约分，把分子分母的公共因式去掉；然后apart把剩余的假分式拆成“多项式 + 真分式”。直接对原式apart也能得到结果，但先cancel能避免输出里出现可以约掉但仍然重复出现的因子。

使用apart时的常见误区是：分母没有完全因式分解。如果分母是一个不能继续分解的高次多项式，apart可能无法给出漂亮的常数分式，这是数学本身的性质，不是代码的问题。遇到这种情况，先用factor(denominator, x)检查分母分解到什么程度，再看是否需要设定extension=True来允许出现根式系数。

4. 把多项式与有理函数接上微积分

4.1 极限：先代入，0/0 再约分

求函数极限时，最基本的策略是“先尝试代入”。对多项式来说，在任意有定义的点处，lim_{x -> a} P(x) = P(a)，可以直接代入。对有理函数来说，如果代入后分母不为零，极限也存在，直接代入即可。

真正需要小心的是代入后得到 0/0 或无穷比无穷。0/0 代表分子分母在同一点都为零，处理办法是约分；无穷比无穷代表分子分母次数关系决定极限值，处理办法是比较最高次项。

用 SymPy 验证：

import sympy as sp x = sp.symbols('x') lim1 = sp.limit((x**2 - 1)/(x - 1), x, 1) print(lim1) # 2

手算时应主动写下：

(x^2 - 1) / (x - 1) = (x - 1)(x + 1) / (x - 1) = x + 1

然后得到极限值是 2。代码只是验证，心里必须清楚先化解再代入。

4.2 导数：幂法则和商法则怎么落到这两类函数上

多项式求导有现成的幂法则：对每一项a_n x^n，导数等于a_n * n * x^(n-1)。组合起来，一个完整的导数还是一个多项式。

f = 3*x**3 - 2*x**2 + x - 7 print(sp.diff(f, x))

输出为：

9*x**2 - 4*x + 1

有理函数求导则要用商法则：

( P(x) / Q(x) )' = ( P'(x)Q(x) - P(x)Q'(x) ) / Q(x)^2

即使不熟练商法则，只要多项式乘法熟练，也能算出结果。工程计算里，导数计算大多交给自动求导框架，但在微积分预备阶段，手算和符号验证并行是建立公式记忆的最好方式。

4.3 积分：逐项积分与部分分式积分

多项式积分使用幂法则的逆运算：对每一项a_n x^n，积分结果是a_n / (n+1) * x^(n+1)，最后加常数 C。

print(sp.integrate(3*x**3 - 2*x**2 + x - 7, x))

输出为：

3*x**4/4 - 2*x**3/3 + x**2/2 - 7*x

有理函数积分的第一选择是先做部分分式分解，再对简单分式逐项积分。看一个完整的例子：

r = (2*x + 1) / (x**2 - x - 2) print(sp.apart(r, x))

分母x^2 - x - 2分解为(x - 2)(x + 1)，分解结果为：

5/(3*(x - 2)) + 1/(3*(x + 1))

然后积分：

print(sp.integrate(r, x))

结果是：

5*log(x - 2)/3 + log(x + 1)/3

加上常数 C 后就是最终答案。可以看到，核心难点其实在前面的因式分解和部分分式，积分本身只是逐项套公式。这也是微积分预备阶段要把多项式与有理函数反复练熟的原因。

5. 学习环境与工程计算里的常见问题

5.1 符号计算的五个高频坑

用 Python 做数学验证时，以下问题最容易把初学者卡住：

第一个是^与**的混淆。数学写作里^表示幂，Python 里^是按位异或，幂必须写**。例如x^2在 Python 中是错误的幂表达，应写成x**2。

第二个是factor没有按预期分解。SymPy 默认在有理数范围内做分解，很多含根式的因子不会被自动展开。遇到这种情况，可以尝试：

sp.factor(x**2 - 2, extension=True)

或者使用sp.gaussian=True处理含虚数因子的场景。

第三个是solve返回空列表。这不一定是代码写错，可能是方程没有解析解，或者根无法用常见函数表达。此时可以使用nsolve做数值求解：

sp.nsolve(x**5 - x - 1, 1)

第四个是对apart输出期望过高。假分式如果不先做除法，输出会同时包含多项式部分和分式部分，看起来不像标准答案。应该先cancel，再apart。

第五个是把有理函数的零点与渐近线搞混。分子等于零产生零点，分母等于零产生纵向渐近线，二者不要混淆。

5.2 从现象倒推问题的排错清单

遇到计算结果不合预期时，不要盲目改代码，按下面顺序排查：

排错顺序应遵循“先输入、后运算、再解释”的原则。先确认表达式输入正确，再看函数调用是否符合该数学工具的前提，最后才怀疑库本身。

5.3 数值环境中的多项式与有理函数注意点

学习阶段用 SymPy 验证手算，生产环境则更常用 NumPy、SciPy 或底层数组库做数值计算。这里要记住几组不同默认行为：

np.roots接收高次到低次系数，返回根；np.poly1d也按高次到低次存储多项式。不要和 SymPy 的coeffs()输出顺序混淆。SymPy 的Poly.coeffs()也是从高次到低次，但如果某项缺失，它不会显式返回 0；对比长度时容易对不上。

浮点求根时，不要用“根恰好等于某个整数”来校验。比如(x - 3)^2的根是重根，数值上会被算成两个非常接近的根，这是正常现象。

生产环境处理有理函数时，还要额外关注数值稳定性。当分母很小接近零时，函数值会非常大，直接计算可能溢出。常用的处理策略包括：先分析定义域，排除分母为零的点；对可能发生消去的因子提前约分；在积分或根轨迹分析中使用符号库先化简，再转数值。

6. 可复用的自查清单与下一步练习

6.1 进入微积分前的自查清单

把这套清单当作每次练习前的固定动作，能极大降低低级错误：

1. 拿到一个函数，先判断它是多项式还是有理函数。
2. 多项式：写出次数、首项系数、常数项。
3. 求零点前先尝试因式分解，而不是直接套求根公式。
4. 除多项式时，确认是否能整除，余式为 0 时说明因式定理成立。
5. 有理函数先看定义域，列出分母为零的点。
6. 能约分的先约分，同时记录哪些点被排除。
7. 假分式先除法，变成“多项式 + 真分式”。
8. 真分式求积分前先做部分分式。
9. 用 SymPy 验证手算结果，但不要只依赖代码，要能解释每一步。
10. 数值环境里用霍纳法或库函数求值，不要直接展开高次幂。

6.2 推荐练习路径

结合计算机验证，建议按以下路径做一轮系统练习：

第一步，手算加代码验证因式分解。对x^4 - 1、x^3 + 8、x^4 - 5x^2 + 4这类表达式，先手算分解，再分别用factor、solve、np.roots对比结果。

第二步，练习对称式的分式约分。构造(x^2 + 3x + 2) / (x^2 - 1)这类题目，先约分，再输出定义域。

第三步，做部分分式展开。自己设一组A、B系数，反推出一个有理函数，再用apart拆开，验证是否回到原始分解。这种“自己出题自己验证”的方式，比只做作业题更能强化结构理解。

第四步，把每一步与微积分接口连起来。选一个有理函数，分别求极限、求导数、做积分，观察每一步中因式分解和约分如何起作用。

第五步，整理自己的错误日志。每当手算结果和 SymPy 不一致，把题目、错误写法、正确写法记录下来。这个日志比任何参考书都更适合你自己的薄弱点。

完成这套练习后，再进入微积分的极限部分会轻松很多。后续如果继续学幂函数、指数函数、三角函数的导数，你会发现它们本质上仍然在复用多项式的运算习惯，只是多了一些新公式。多项式与有理函数不是微积分里最难的部分，但它们是让后面所有计算能顺畅进行的地基。每一处因式分解，每一次部分分式化简，都会在极限、导数、积分的世界里找到对应的回响。