搞定可分离变量的微分方程最佳实践
刚把网上抄来的 Python 代码扔进终端，回车一敲，屏幕直接弹出一串红色的 TypeError 或者 SyntaxError。别慌，这不是你的锅，是那些“复制粘贴党”没把上下文讲清楚。很多教程只给你结果，不告诉你为什么这么写，导致你连报错在哪一行都找不到。今天咱们不整虚的，直接上最佳实践。
我是做运维开发出身，平时写脚本、调接口是常态，但最近为了搞一个物理仿真项目，不得不回头啃高数里的可分离变量的微分方程。发现很多初学者（包括刚转行的运维兄弟）一看到数学公式就头大，觉得这是数学系的事，跟自己没关系。大错特错。在工程落地中，无论是模拟温度变化、计算信号衰减，还是处理日志中的异常波动，本质都是在解这类方程。
这篇文章就是为你准备的。我不堆砌复杂的数学推导，而是从“代码怎么跑通”和“原理怎么理解”两个维度，手把手带你搞定可分离变量的微分方程。哪怕你微积分基础已经还给老师了，只要会 Python，跟着做就能出结果。
概念速懂：别被公式吓跑
在动手之前，咱们先把“可分离变量”这个概念掰开了揉碎了说。
很多教程一上来就扔个 \(\frac{dy}{dx} = f(x)g(y)\) 出来，然后说“移项、积分”。你一脸懵逼：移项？移哪边？积分？积谁？
咱们换个说法。想象你在开车，速度 \(v\)（即 \(\frac{dy}{dx}\)）取决于两个因素：
当前的路况 \(x\)（比如是高速还是堵车，这是 \(f(x)\)）。
你当前的油门状态 \(y\)（比如你踩得深不深，这是 \(g(y)\)）。
可分离变量的意思就是：这两个因素是“独立”作用的。路况变差，只会按比例改变速度；你踩油门，也只会按比例改变速度。它们没有那种“路况好所以你必须踩油门”这种耦合关系。
所以，解这类方程的核心思路只有一步：把含 \(y\) 的项全扔到 \(dy\) 那边，把含 \(x\) 的项全扔到 \(dx\) 那边。
即：
\(\frac{dy}{g(y)} = f(x) dx\)
然后两边同时积分。就这么简单。剩下的就是代数运算和积分技巧了。对于程序员来说，你可以把这理解为：把一个复杂的函数调用，拆分成两个独立的函数调用，分别执行，最后合并结果。
环境准备：Python 是最好的计算工具
既然是编程领域的教程，咱们自然不用纸笔算，而是用 Python。这里有两个关键库，你必须装好：
SymPy: 这是 Python 里的“代数引擎”，专门处理符号运算。它能帮你做积分、求导、化简，就像个超级计算器，但更聪明，因为它懂数学符号。
Matplotlib: 用来画图。解完方程还得看图形，直观验证你的解对不对。
如果你的环境里还没装，打开终端（CMD 或 PowerShell），运行：
pip install sympy matplotlib
避坑提示：确保你的 Python 版本是 3.8 以上。SymPy 对旧版 Python 的支持已经很差了，很多新特性用不了。另外，如果你用的是公司内网，可能需要配置代理才能 pip 安装，这个运维同学应该很熟悉我就不展开了。
为什么选 SymPy 而不是直接调用 scipy.integrate？因为 scipy 做的是数值积分，它给你的是一个具体的数或者数组，而我们要的是解析解（也就是一个数学公式）。SymPy 能直接告诉你 \(y(x) = \dots\) 这个表达式，这对理解模型至关重要。
核心语法：SymPy 解方程的正确姿势
很多教程在这里会翻车，因为他们直接教你 sympy.solve。注意，solve 是解代数方程的（比如 \(x^2 - 4 = 0\)），不是解微分方程的。
解微分方程，SymPy 的官方文档推荐使用的是 dsolve 函数。
这里有一个巨大的坑：变量必须是 Symbol，不能是整数或浮点数。
很多新手会写成这样：
# 错误示范
x = 1
y = sympy.Function('y')
这样写，SymPy 会把 x 当成具体的数字 1，而不是变量。
正确的写法是：
import sympy as sp
# 定义符号变量
x = sp.symbols('x')
# 定义未知函数 y(x)
y = sp.Function('y')
接下来，我们要定义微分方程。对于可分离变量的微分方程，形式通常是 \(y' = f(x)g(y)\)。
假设我们要解这个方程：
\(\frac{dy}{dx} = x y\)
也就是 \(y' = x y\)。
在 SymPy 里，怎么表示 \(y'\)？用 y(x).diff(x) 或者更简洁的 y(x).diff()。
完整的方程对象构造如下：
eq = sp.Eq(y(x).diff(x), x * y(x))
这时候，eq 就是一个 SymPy 的 Equation 对象，它代表了 \(\frac{dy}{dx} = xy\)。
完整代码示例：从定义到可视化
光说不练假把式。下面是一段完整的、可直接运行的代码。我把它分成了三部分：定义问题、求解、可视化验证。
1. 基础求解代码
import sympy as sp
import matplotlib.pyplot as plt
import numpy as np
# 1. 定义符号
x = sp.symbols('x')
y = sp.Function('y')
# 2. 定义微分方程: dy/dx = x * y
# 注意：这里是可分离变量形式，f(x)=x, g(y)=y
ode = sp.Eq(y(x).diff(x), x * y(x))
# 3. 求解微分方程
# 使用 dsolve 函数，这是 SymPy 处理 ODE 的标准入口
solution = sp.dsolve(ode, y(x))
print(解析解为:)
print(solution)
# 4. 假设初始条件 y(0) = 1，确定积分常数
# 如果不加初始条件，解里会带一个 C1
# 我们这里为了画图方便，手动代入
C1 = solution.rhs # 右边是解的表达式
# 解的形式通常是 y(x) = C1 * exp(x^2 / 2)
# 我们需要求出 C1 的值
# 获取解中的积分常数
# 在 SymPy 中，dsolve 返回的解里，积分常数通常命名为 C1
# 我们可以通过替换 x=0, y(0)=1 来求 C1
sol_with_C1 = solution
# 将 x 替换为 0，y(x) 替换为 1
C1_value = sol_with_C1.subs({x: 0, y(x): 1})
# 此时 C1_value 应该是一个包含 C1 的方程，比如 C1 = 1
# 我们需要解这个方程
C1_sol = sp.solve(C1_value, sp.Symbol('C1'))
print(f积分常数 C1 的值为: {C1_sol})
# 假设 C1 = 1
final_solution = sol_with_C1.subs(sp.Symbol('C1'), C1_sol[0])
print(f特解为: {final_solution})
# 5. 可视化
# 将 SymPy 表达式转换为 Lambda 函数，以便用 NumPy 计算数值
func = sp.lambdify(x, final_solution.rhs, modules='numpy')
# 生成 x 的数据点
x_vals = np.linspace(-2, 2, 400)
y_vals = func(x_vals)
# 绘图
plt.figure(figsize=(10, 6))
plt.plot(x_vals, y_vals, label='y = exp(x^2 / 2)', color='blue', linewidth=2)
plt.title('Solution to dy/dx = x*y with y(0)=1')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True, linestyle='--', alpha=0.6)
plt.legend()
plt.axhline(0, color='black', linewidth=0.5)
plt.axvline(0, color='black', linewidth=0.5)
plt.show()
代码逐行解析：
sp.symbols('x'): 这是最关键的一步。告诉 SymPy，x 是一个符号，不是数字。
sp.Eq(...): 构造等式对象。左边是导数，右边是表达式。
sp.dsolve(...): 核心函数。它会自动识别方程类型。对于可分离变量方程，它会执行“分离变量 - 积分”的过程。
sp.lambdify(...): 这是 SymPy 和 NumPy 之间的桥梁。SymPy 的表达式不能直接用于数组运算，lambdify 把它转换成了 Python 的 lambda 函数，这个函数接受 NumPy 数组，返回 NumPy 数组。
2. 进阶：处理更复杂的可分离方程
上面的例子 \(y'=xy\) 比较简单。咱们来一个稍微难点的，涉及三角函数的：
\(\frac{dy}{dx} = \cos(x) \sin(y)\)
这个方程也是可分离的：
\(\frac{1}{\sin(y)} dy = \cos(x) dx\)
\(\csc(y) dy = \cos(x) dx\)
积分左边 \(\int \csc(y) dy = \ln|\csc(y) - \cot(y)|\)，右边 \(\int \cos(x) dx = \sin(x)\)。
所以解大概是 \(\ln|\csc(y) - \cot(y)| = \sin(x) + C\)。
SymPy 能自动处理吗？能。
import sympy as sp
x = sp.symbols('x')
y = sp.Function('y')
# 定义方程 dy/dx = cos(x) * sin(y)
ode2 = sp.Eq(y(x).diff(x), sp.cos(x) * sp.sin(y(x)))
# 求解
sol2 = sp.dsolve(ode2, y(x))
print(复杂方程的解析解:)
print(sol2)
# 注意：对于三角函数，SymPy 给出的解可能比较繁琐
# 可能需要手动化简，或者使用 sp.simplify(sol2)
simplified_sol = sp.simplify(sol2)
print(化简后的解:)
print(simplified_sol)
运行这段代码，你会发现 SymPy 给出的解可能是一串隐式方程，或者带有 InverseFunction 之类的东西。这时候，最佳实践是：如果解析解太复杂，不要死磕解析解，转而使用数值解法（如 scipy.integrate.odeint），或者对 SymPy 的结果进行近似处理。
常见报错：为什么你的代码跑不通
在调试过程中，我总结了三个最高频的报错，占了你 90% 的麻烦。
1. AttributeError: 'Symbol' object has no attribute 'diff'
原因：你用了 x.diff()。
解释：x 是一个符号（Symbol），它不是函数，所以没有 .diff() 方法。只有函数（Function）才有导数。
解决：确保你对的是 y(x) 调用 .diff()，而不是对 x 或 y 直接调用。
# 错误
# x.diff()
# y.diff()
# 正确
y(x).diff(x)
2. TypeError: Cannot multiply scalar and function 或者 运算结果全是符号
原因：你在定义方程时，混用了 Python 的原生类型和 SymPy 的符号类型。
解释：比如你写了 x * y(x)，但这里的 x 是你之前定义的 sp.symbols('x')，这是对的。但如果你之前不小心执行过 x = 1，那么 x 就是整数 1，1 * y(x) 就是一个纯函数，SymPy 可能无法正确识别方程结构，或者导致后续积分出错。
解决：在每次脚本开头，重新定义符号。
x = sp.symbols('x')
y = sp.Function('y')
并且，检查你的代码里有没有地方意外覆盖了 x 或 y 变量名。
3. dsolve 返回 None 或者提示 Unable to solve
原因：方程形式过于复杂，或者不是标准的可分离形式。
解释：虽然 SymPy 很强大，但它不是万能的。有些看似可分离的方程，如果包含复杂的非线性项，SymPy 可能找不到解析解。
解决：
尝试对方程进行手动化简。比如，如果方程是 \(y' = \frac{x^2}{y}\)，先写成 \(y y' = x^2\)，再交给 SymPy。
检查 ode 对象是否正确。打印 ode 看看 SymPy 识别到的方程是不是你心里想的那个。
如果实在解不出来，参考 SymPy 官方文档中的 dsolve 参数，尝试指定 hint='separable' 强制它按可分离变量处理（如果它没自动识别的话）。
sol = sp.dsolve(ode, y(x), hint='separable')
小结
搞定可分离变量的微分方程，核心不在于数学推导有多复杂，而在于工具用得对不对。
概念上：记住“分离”就是“各回各家”，含 y 的跟 dy 走，含 x 的跟 dx 走。
工具上：SymPy 的 dsolve 是首选，lambdify 是通往数值计算和可视化的桥梁。
细节上：符号定义要纯净，变量名不要污染，报错要看堆栈的第一行。
对于运维开发同学来说，理解这个过程的另一个好处是，它能帮你更好地阅读和理解那些涉及物理模型、信号处理的第三方库源码。当你知道底层是在解这类方程时，你就不会再盲目地调参，而是能结合业务逻辑去判断结果的合理性。
代码只是手段，理解背后的数学逻辑，才能让你在面对更复杂的偏微分方程或非线性方程时，不至于手足无措。
这篇文章只是入门。如果你想深入，可以去读一下 SymPy 的官方文档中关于 diff 和 integrate 的章节，那里有很多边界情况的处理技巧。
还有什么不懂的？评论区留言挨个回。 
长河君 · 2026/9/22 4:13:06 · 阅读 1.2k 搞定可分离变量的微分方程最佳实践
搞定可分离变量的微分方程最佳实践
刚把网上抄来的 Python 代码扔进终端，回车一敲，屏幕直接弹出一串红色的 TypeError 或者 SyntaxError。别慌，这不是你的锅，是那些“复制粘贴党”没把上下文讲清楚。很多教程只给你结果，不告诉你为什么这么写，导致你连报错在哪一行都找不到。今天咱们不整虚的，直接上最佳实践。
我是做运维开发出身，平时写脚本、调接口是常态，但最近为了搞一个物理仿真项目，不得不回头啃高数里的可分离变量的微分方程。发现很多初学者（包括刚转行的运维兄弟）一看到数学公式就头大，觉得这是数学系的事，跟自己没关系。大错特错。在工程落地中，无论是模拟温度变化、计算信号衰减，还是处理日志中的异常波动，本质都是在解这类方程。
这篇文章就是为你准备的。我不堆砌复杂的数学推导，而是从“代码怎么跑通”和“原理怎么理解”两个维度，手把手带你搞定可分离变量的微分方程。哪怕你微积分基础已经还给老师了，只要会 Python，跟着做就能出结果。
概念速懂：别被公式吓跑
在动手之前，咱们先把“可分离变量”这个概念掰开了揉碎了说。
很多教程一上来就扔个 \(\frac{dy}{dx} = f(x)g(y)\) 出来，然后说“移项、积分”。你一脸懵逼：移项？移哪边？积分？积谁？
咱们换个说法。想象你在开车，速度 \(v\)（即 \(\frac{dy}{dx}\)）取决于两个因素：
当前的路况 \(x\)（比如是高速还是堵车，这是 \(f(x)\)）。
你当前的油门状态 \(y\)（比如你踩得深不深，这是 \(g(y)\)）。
可分离变量的意思就是：这两个因素是“独立”作用的。路况变差，只会按比例改变速度；你踩油门，也只会按比例改变速度。它们没有那种“路况好所以你必须踩油门”这种耦合关系。
所以，解这类方程的核心思路只有一步：把含 \(y\) 的项全扔到 \(dy\) 那边，把含 \(x\) 的项全扔到 \(dx\) 那边。
即：
\(\frac{dy}{g(y)} = f(x) dx\)
然后两边同时积分。就这么简单。剩下的就是代数运算和积分技巧了。对于程序员来说，你可以把这理解为：把一个复杂的函数调用，拆分成两个独立的函数调用，分别执行，最后合并结果。
环境准备：Python 是最好的计算工具
既然是编程领域的教程，咱们自然不用纸笔算，而是用 Python。这里有两个关键库，你必须装好：
SymPy: 这是 Python 里的“代数引擎”，专门处理符号运算。它能帮你做积分、求导、化简，就像个超级计算器，但更聪明，因为它懂数学符号。
Matplotlib: 用来画图。解完方程还得看图形，直观验证你的解对不对。
如果你的环境里还没装，打开终端（CMD 或 PowerShell），运行：
pip install sympy matplotlib
避坑提示：确保你的 Python 版本是 3.8 以上。SymPy 对旧版 Python 的支持已经很差了，很多新特性用不了。另外，如果你用的是公司内网，可能需要配置代理才能 pip 安装，这个运维同学应该很熟悉我就不展开了。
为什么选 SymPy 而不是直接调用 scipy.integrate？因为 scipy 做的是数值积分，它给你的是一个具体的数或者数组，而我们要的是解析解（也就是一个数学公式）。SymPy 能直接告诉你 \(y(x) = \dots\) 这个表达式，这对理解模型至关重要。
核心语法：SymPy 解方程的正确姿势
很多教程在这里会翻车，因为他们直接教你 sympy.solve。注意，solve 是解代数方程的（比如 \(x^2 - 4 = 0\)），不是解微分方程的。
解微分方程，SymPy 的官方文档推荐使用的是 dsolve 函数。
这里有一个巨大的坑：变量必须是 Symbol，不能是整数或浮点数。
很多新手会写成这样：
# 错误示范
x = 1
y = sympy.Function('y')
这样写，SymPy 会把 x 当成具体的数字 1，而不是变量。
正确的写法是：
import sympy as sp
# 定义符号变量
x = sp.symbols('x')
# 定义未知函数 y(x)
y = sp.Function('y')
接下来，我们要定义微分方程。对于可分离变量的微分方程，形式通常是 \(y' = f(x)g(y)\)。
假设我们要解这个方程：
\(\frac{dy}{dx} = x y\)
也就是 \(y' = x y\)。
在 SymPy 里，怎么表示 \(y'\)？用 y(x).diff(x) 或者更简洁的 y(x).diff()。
完整的方程对象构造如下：
eq = sp.Eq(y(x).diff(x), x * y(x))
这时候，eq 就是一个 SymPy 的 Equation 对象，它代表了 \(\frac{dy}{dx} = xy\)。
完整代码示例：从定义到可视化
光说不练假把式。下面是一段完整的、可直接运行的代码。我把它分成了三部分：定义问题、求解、可视化验证。
1. 基础求解代码
import sympy as sp
import matplotlib.pyplot as plt
import numpy as np
# 1. 定义符号
x = sp.symbols('x')
y = sp.Function('y')
# 2. 定义微分方程: dy/dx = x * y
# 注意：这里是可分离变量形式，f(x)=x, g(y)=y
ode = sp.Eq(y(x).diff(x), x * y(x))
# 3. 求解微分方程
# 使用 dsolve 函数，这是 SymPy 处理 ODE 的标准入口
solution = sp.dsolve(ode, y(x))
print(解析解为:)
print(solution)
# 4. 假设初始条件 y(0) = 1，确定积分常数
# 如果不加初始条件，解里会带一个 C1
# 我们这里为了画图方便，手动代入
C1 = solution.rhs # 右边是解的表达式
# 解的形式通常是 y(x) = C1 * exp(x^2 / 2)
# 我们需要求出 C1 的值
# 获取解中的积分常数
# 在 SymPy 中，dsolve 返回的解里，积分常数通常命名为 C1
# 我们可以通过替换 x=0, y(0)=1 来求 C1
sol_with_C1 = solution
# 将 x 替换为 0，y(x) 替换为 1
C1_value = sol_with_C1.subs({x: 0, y(x): 1})
# 此时 C1_value 应该是一个包含 C1 的方程，比如 C1 = 1
# 我们需要解这个方程
C1_sol = sp.solve(C1_value, sp.Symbol('C1'))
print(f积分常数 C1 的值为: {C1_sol})
# 假设 C1 = 1
final_solution = sol_with_C1.subs(sp.Symbol('C1'), C1_sol[0])
print(f特解为: {final_solution})
# 5. 可视化
# 将 SymPy 表达式转换为 Lambda 函数，以便用 NumPy 计算数值
func = sp.lambdify(x, final_solution.rhs, modules='numpy')
# 生成 x 的数据点
x_vals = np.linspace(-2, 2, 400)
y_vals = func(x_vals)
# 绘图
plt.figure(figsize=(10, 6))
plt.plot(x_vals, y_vals, label='y = exp(x^2 / 2)', color='blue', linewidth=2)
plt.title('Solution to dy/dx = x*y with y(0)=1')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True, linestyle='--', alpha=0.6)
plt.legend()
plt.axhline(0, color='black', linewidth=0.5)
plt.axvline(0, color='black', linewidth=0.5)
plt.show()
代码逐行解析：
sp.symbols('x'): 这是最关键的一步。告诉 SymPy，x 是一个符号，不是数字。
sp.Eq(...): 构造等式对象。左边是导数，右边是表达式。
sp.dsolve(...): 核心函数。它会自动识别方程类型。对于可分离变量方程，它会执行“分离变量 - 积分”的过程。
sp.lambdify(...): 这是 SymPy 和 NumPy 之间的桥梁。SymPy 的表达式不能直接用于数组运算，lambdify 把它转换成了 Python 的 lambda 函数，这个函数接受 NumPy 数组，返回 NumPy 数组。
2. 进阶：处理更复杂的可分离方程
上面的例子 \(y'=xy\) 比较简单。咱们来一个稍微难点的，涉及三角函数的：
\(\frac{dy}{dx} = \cos(x) \sin(y)\)
这个方程也是可分离的：
\(\frac{1}{\sin(y)} dy = \cos(x) dx\)
\(\csc(y) dy = \cos(x) dx\)
积分左边 \(\int \csc(y) dy = \ln|\csc(y) - \cot(y)|\)，右边 \(\int \cos(x) dx = \sin(x)\)。
所以解大概是 \(\ln|\csc(y) - \cot(y)| = \sin(x) + C\)。
SymPy 能自动处理吗？能。
import sympy as sp
x = sp.symbols('x')
y = sp.Function('y')
# 定义方程 dy/dx = cos(x) * sin(y)
ode2 = sp.Eq(y(x).diff(x), sp.cos(x) * sp.sin(y(x)))
# 求解
sol2 = sp.dsolve(ode2, y(x))
print(复杂方程的解析解:)
print(sol2)
# 注意：对于三角函数，SymPy 给出的解可能比较繁琐
# 可能需要手动化简，或者使用 sp.simplify(sol2)
simplified_sol = sp.simplify(sol2)
print(化简后的解:)
print(simplified_sol)
运行这段代码，你会发现 SymPy 给出的解可能是一串隐式方程，或者带有 InverseFunction 之类的东西。这时候，最佳实践是：如果解析解太复杂，不要死磕解析解，转而使用数值解法（如 scipy.integrate.odeint），或者对 SymPy 的结果进行近似处理。
常见报错：为什么你的代码跑不通
在调试过程中，我总结了三个最高频的报错，占了你 90% 的麻烦。
1. AttributeError: 'Symbol' object has no attribute 'diff'
原因：你用了 x.diff()。
解释：x 是一个符号（Symbol），它不是函数，所以没有 .diff() 方法。只有函数（Function）才有导数。
解决：确保你对的是 y(x) 调用 .diff()，而不是对 x 或 y 直接调用。
# 错误
# x.diff()
# y.diff()
# 正确
y(x).diff(x)
2. TypeError: Cannot multiply scalar and function 或者 运算结果全是符号
原因：你在定义方程时，混用了 Python 的原生类型和 SymPy 的符号类型。
解释：比如你写了 x * y(x)，但这里的 x 是你之前定义的 sp.symbols('x')，这是对的。但如果你之前不小心执行过 x = 1，那么 x 就是整数 1，1 * y(x) 就是一个纯函数，SymPy 可能无法正确识别方程结构，或者导致后续积分出错。
解决：在每次脚本开头，重新定义符号。
x = sp.symbols('x')
y = sp.Function('y')
并且，检查你的代码里有没有地方意外覆盖了 x 或 y 变量名。
3. dsolve 返回 None 或者提示 Unable to solve
原因：方程形式过于复杂，或者不是标准的可分离形式。
解释：虽然 SymPy 很强大，但它不是万能的。有些看似可分离的方程，如果包含复杂的非线性项，SymPy 可能找不到解析解。
解决：
尝试对方程进行手动化简。比如，如果方程是 \(y' = \frac{x^2}{y}\)，先写成 \(y y' = x^2\)，再交给 SymPy。
检查 ode 对象是否正确。打印 ode 看看 SymPy 识别到的方程是不是你心里想的那个。
如果实在解不出来，参考 SymPy 官方文档中的 dsolve 参数，尝试指定 hint='separable' 强制它按可分离变量处理（如果它没自动识别的话）。
sol = sp.dsolve(ode, y(x), hint='separable')
小结
搞定可分离变量的微分方程，核心不在于数学推导有多复杂，而在于工具用得对不对。
概念上：记住“分离”就是“各回各家”，含 y 的跟 dy 走，含 x 的跟 dx 走。
工具上：SymPy 的 dsolve 是首选，lambdify 是通往数值计算和可视化的桥梁。
细节上：符号定义要纯净，变量名不要污染，报错要看堆栈的第一行。
对于运维开发同学来说，理解这个过程的另一个好处是，它能帮你更好地阅读和理解那些涉及物理模型、信号处理的第三方库源码。当你知道底层是在解这类方程时，你就不会再盲目地调参，而是能结合业务逻辑去判断结果的合理性。
代码只是手段，理解背后的数学逻辑，才能让你在面对更复杂的偏微分方程或非线性方程时，不至于手足无措。
这篇文章只是入门。如果你想深入，可以去读一下 SymPy 的官方文档中关于 diff 和 integrate 的章节，那里有很多边界情况的处理技巧。
还有什么不懂的？评论区留言挨个回。