在数值分析领域，误差是无法回避的核心问题。无论是科学计算、工程模拟还是数据分析，误差的累积都可能导致结果偏离真实值，甚至引发 “蝴蝶效应” 式的严重偏差。本文将聚焦数值分析中的两大基础误差类型 ——舍入误差与截断误差，结合 Python 实例解析其产生原理、影响机制，为后续更复杂的数值计算打下坚实基础。

误差的基本概念：为什么误差无法避免？

准确度与精确度：误差分析的 “两个维度”

准确度：衡量计算结果与真实值的接近程度。反映的是 “系统误差”（如方法本身的偏差、仪器校准误差）。例如，用尺子测量一根 10cm 的木棒，若多次结果均为 9.5cm，说明准确度低（偏离真实值）；若结果均为 10.0cm，说明准确度高。

精确度：衡量多次重复计算结果之间的一致性程度。反映的是 “随机误差”（如舍入误差、环境干扰）。例如，同样测量 10cm 木棒，若多次结果为 9.8cm、9.9cm、10.1cm（平均值接近 10cm，但是结果分散），说明精确度低；若结果均为 9.5cm、9.51cm、9.49cm（结果集中），说明精确度高。

误差定义：绝对误差与相对误差

绝对误差（Absolute Error, AE）

定义：计算值（近似值）与真实值的差值的绝对值，反映误差的 “绝对大小”。

设真实值为​x∗，近似值为​x，则绝对误差为：

AE = |x - x^*|

特点：

  1. 具有与真实值相同的单位（如长度误差的单位是 cm，温度误差的单位是℃）；​
  2. 无法单独判断误差的严重性（例如，1cm 的误差对 10cm 的木棒是严重的，但对 100m 的跑道是微小的）。

相对误差（Relative Error, RE）

定义：绝对误差与真实值绝对值的比值，反映误差的 “相对比例”，通常用百分比表示（称为 “相对百分误差”）。

数学表达式为：

RE = \frac{|x - x^*|}{|x^*|} \quad (x^* \neq 0)

通常我们将相对误差乘以100%，即百分比相对误差（Relative Percent Error, RPE）：

RPE = RE \times 100\%

特点：​

  1. 无单位（是一个比例），可跨领域比较误差严重程度；​
  2. 当真实值接近 0 时，相对误差可能趋于无穷大，此时需用绝对误差评估。

误差的标准化：

在上述的误差分析中，我们计算绝对误差（AE）和相对误差（RE）时，均以真实值为基准。但在实际场景中，真实值往往难以获取（例如测量未知物理量、求解复杂方程），此时需用近似值作为基准实现误差标准化。

近似绝对误差（Approximate Absolute Error, AAE）

设参考近似值为\hat{x}，某一近似值为 ​x_i，则：

AAE = |x_i-\hat{x}|

近似相对误差（Approximate Relative Error, ARE）

ARE = \frac{|x_i-\hat{x}|}{|\hat{x}|} \quad(\hat{x} \neq 0)

可接受百分比相对误差

在执行迭代数值方法时，我们必须考虑何时停止，为此我们定义一个可接受的百分比相对误差，重复计算直到百分比相对误差小于该值时停止，我们认为结果在规定的可接受水平内。

舍入误差（Round-off Error）

舍入误差的本质

舍入误差源于计算机对数值的有限精度表示。

以我们最熟悉的十进制为例，1/3=0.333... 是无限循环小数，无法用有限位数精确表示；同理，计算机采用的二进制中，许多十进制有限小数（如 0.1）也是无限循环小数，只能通过 “四舍五入” 或 “截断” 的方式保留有限位，从而产生误差。

Python 中的舍入误差实例

在 Python 中，浮点数（float 类型）遵循IEEE 754 标准，采用 64 位双精度存储：​

  • 1 位符号位（正 / 负）​
  • 11 位指数位（表示数值的量级）​
  • 52 位尾数位（表示数值的精度，约对应十进制 15-17 位有效数字）​

这意味着，超过 52 位二进制精度的数值，在存储时必然会被 “舍入”，从而引入误差。

案例一：0.1 + 0.2

 你可能会直觉认为是 0.3，但在 Python 中运行后会发现结果是0.30000000000000004：

a = 0.1
b = 0.2
print(a + b)
print(a + b == 0.3)

输出：

0.30000000000000004
False

为什么会出现这种情况？因为 0.1 和 0.2 在二进制中都是无限循环小数：​

  • 0.1（十进制）= 0.0001100110011...（二进制，循环节 “0011”）​
  • 0.2（十进制）= 0.001100110011...（二进制，循环节 “0011”）​

当计算机用 52 位尾数位存储时，必须对循环部分进行舍入，导致存储的0.1和0.2本身就存在微小误差，相加后误差累积，最终结果与 0.3 产生偏差。

案例二： “小数累积误差”：

在循环中重复累加一个小数，误差会随迭代次数增加而放大：

result = 0.0
for _ in range(100000):
    result += 0.00001
print(result)

输出：

0.9999999999980838

在Python中如何减小舍入误差

使用 decimal 模块提高精度：

decimal模块的具体用法小编后续会单独补充，它允许自定义浮点数精度，通过设置足够的有效位数，可显著降低舍入误差：

from decimal import Decimal, getcontext

getcontext().prec = 50  # 设置50位有效数字
a = Decimal('0.00001')  # 注意：需用字符串初始化，避免直接传入float
b = Decimal(0.00001)  #直接传入float时，0.00001已因float的二进制存储产生舍入误差
result1 = Decimal('0.0')
result2 = Decimal(0.0)
for _ in range(100000):
    result1 += a
    result2 += b
print(result1)
print(result2)

输出：

1.00000
1.0000000000000000818030539140313095458623138259604

避免小数直接比较：

判断两个浮点数是否相等时，不要用==，而是判断它们的差值是否小于一个极小的阈值（如1e-9）：

def is_equal(a, b):
    return abs(a - b) < 1e-9

print(is_equal(0.1 + 0.2, 0.3))

输出：

True

优先使用整数运算：

若场景允许（如货币计算），可将小数转换为整数（如元→分），避免浮点数操作：

price = 105  # 1.05元
quantity = 20
total = price * quantity  # 2100分 = 21.00元（无误差）
print(total / 100)  # 输出：21.0

截断误差（Truncation Error）

截断误差的来源：

截断误差是由于使用近似值代替精确的数学过程、用有限次运算近似无限次运算或用简单函数近似复杂函数而产生的误差。

例如：

  1. 无穷级数求和（如泰勒级数）：只能计算前 n 项，截断后续无穷多项；​
  2. 数值微分 / 积分：用离散点的差值近似连续的导数 / 积分；​
  3. 迭代算法：达到预设迭代次数或精度阈值后停止计算。

Python 中的截断误差实例

泰勒级数近似正弦函数

\sin(x) = x - \frac {x^3}{3!}+\frac{x^5}{5!}-\frac{x^7}{7!}+\dots+(-1)^n\frac{x^{2n+1}}{(2n+1)!}+R_n(x)

其中R_n(x)​是截断误差（余项）。若只计算前 k 项，就会引入截断误差。

我们用 Python 实现泰勒级数近似，并对比与math.sin（高精度计算）的误差：

import math

def taylor_sin(x,n_terms):
    """
    计算x的n_terms阶泰勒展开的正弦值
    """
    result = 0.0
    for i in range(n_terms):
        #第i项的泰勒展开式
        term = (-1)**i * x**(2*i+1) / math.factorial(2*i+1)
        result += term
    return result

x = math.pi/2

for n in [1, 3, 5, 7]:
    approx_value = taylor_sin(x, n)
    trunc_error = abs(math.sin(x) - approx_value)
    print(f"前{n}项近似, 近似值={approx_value}, 误差={trunc_error}")

输出：

前1项近似, 近似值=1.5707963267948966, 误差=0.5707963267948966
前3项近似, 近似值=1.0045248555348174, 误差=0.004524855534817407
前5项近似, 近似值=1.0000035425842861, 误差=3.542584286142514e-06
前7项近似, 近似值=1.0000000006627803, 误差=6.627802751069112e-10

可见：随着项数增加，截断误差逐渐减小—— 这是截断误差的典型特征：近似方法的 “复杂度”（如阶数、迭代次数）越高，截断误差越小（但是涉及的浮点数运算次数就越多，每一步运算引入的微小舍入误差会不断叠加，可能导致舍入误差随之增加）。

数值微分的截断误差

数值微分中，常用 “向前差分” 近似导数：

f'(x)\approx\frac{f(x+h)-f(x)}{h}

其中 h 是步长。理论上，h 越小，近似越精确，但 h 过小时会引入严重的舍入误差（因​f(x+h)与f(x)​的差值接近机器精度）。

我们以f(x)=x^2（理论导数f'(x)=2x）为例，测试步长 h 对截断误差的影响：

def forward_diff(f, x, h):
    """
    利用一阶导数公式计算f(x+h) - f(x) / h
    """
    return (f(x+h) - f(x)) / h

f = lambda x: x**2
x = 2.0
true_deriv = 2 * x

for h in [1e-2, 1e-4, 1e-6, 1e-8, 1e-10]:
    approx_deriv = forward_diff(f, x, h)
    trunc_error = abs(true_deriv - approx_deriv)
    print(f"h={h}, 近似导数={approx_deriv}, 误差={trunc_error}")

输出：

h=0.01, 近似导数=4.009999999999891, 误差=0.009999999999891429
（截断误差主导）
h=0.0001, 近似导数=4.0001000000078335, 误差=0.0001000000078335006
（截断误差主导）
h=1e-06, 近似导数=4.0000010006480125, 误差=1.000648012450256e-06
（截断误差主导）
h=1e-08, 近似导数=3.999999975690116, 误差=2.43098838836886e-08
（截断误差与舍入误差平衡）
h=1e-10, 近似导数=4.000000330961484, 误差=3.309614839963615e-07
（舍入误差主导）

这个案例揭示了数值计算中的核心权衡：步长 h 减小，截断误差减小，但舍入误差增大；存在一个 “最优步长”（本例中约 1e-8），使总误差最小。

如何减小截断误差

控制截断误差的核心是 “选择更高精度的近似方法” 或 “优化计算参数”：

提高近似方法的阶数：

例如，用 “中心差分”（二阶精度）替代 “向前差分”（一阶精度）：

“中心差分的截断误差阶数为O(h^2)（步长 h 减小 10 倍，截断误差减小 100 倍），而向前差分是O(h)（步长减小 10 倍，误差减小 10 倍）”。

def forward_diff(f, x, h):
    """
    利用一阶导数公式计算f(x+h) - f(x) / h
    """
    return (f(x+h) - f(x)) / h
def central_diff(f, x, h):
    """
    利用二阶导数公式计算(f(x+h) - f(x-h)) / (2*h)
    """
    return (f(x+h) - f(x-h)) / (2*h)

f = lambda x: x**2
x = 2.0
true_deriv = 2 * x

for h in [1e-2, 1e-4, 1e-6, 1e-8, 1e-10]:
    approx_deriv_of_forward = forward_diff(f, x, h)
    approx_deriv_of_central = central_diff(f, x, h)
    trunc_error_of_forward = abs(true_deriv - approx_deriv_of_forward)
    trunc_error_of_central = abs(true_deriv - approx_deriv_of_central)
    print(f"h={h}, 前向差分近似, 近似值={approx_deriv_of_forward}, 误差={trunc_error_of_forward}")
    print(f"h={h}, 中心差分近似, 近似值={approx_deriv_of_central}, 误差={trunc_error_of_central}")

输出：

h=0.01, 前向差分近似, 近似值=4.009999999999891, 误差=0.009999999999891429
h=0.01, 中心差分近似, 近似值=3.999999999999937, 误差=6.306066779870889e-14
h=0.0001, 前向差分近似, 近似值=4.0001000000078335, 误差=0.0001000000078335006
h=0.0001, 中心差分近似, 近似值=4.000000000004, 误差=4.000355602329364e-12
h=1e-06, 前向差分近似, 近似值=4.0000010006480125, 误差=1.000648012450256e-06
h=1e-06, 中心差分近似, 近似值=4.000000000115023, 误差=1.1502265806484502e-10
h=1e-08, 前向差分近似, 近似值=3.999999975690116, 误差=2.43098838836886e-08
h=1e-08, 中心差分近似, 近似值=3.999999975690116, 误差=2.43098838836886e-08
h=1e-10, 前向差分近似, 近似值=4.000000330961484, 误差=3.309614839963615e-07
h=1e-10, 中心差分近似, 近似值=4.000000330961484, 误差=3.309614839963615e-07

分析：

  1. 当h=1e−2时，中心差分的截断误差（1e−14）远小于向前差分（1e−2），体现高阶方法的优势；
  2. 当h≤1e−8时，中心差分的截断误差已减小到1e−16以下（接近机器精度，可忽略），但舍入误差因 “抵消误差” 增大到2e−8，最终总误差与向前差分持平；
  3. 当h=1e−10时，两种方法的 “抵消误差” 都进一步放大，导致总误差同步上升到3e−7，此时高阶方法的精度优势完全消失。

这个实验结果揭示了数值计算中的一个核心原则 ——并非 “步长越小越好”，也并非 “阶数越高越好”，需找到 “截断误差与舍入误差的平衡点”。

优化迭代次数 / 步长：

对于迭代算法（如牛顿法、梯度下降），需设置合理的停止条件（如 “误差小于 1e-9” 或 “迭代次数不超过 1000”），避免过早停止（截断误差大）或过度迭代（浪费计算资源）。

使用专门的数值计算库：

Python 的numpy、scipy等库已内置高精度数值算法（如scipy.integrate用于积分，scipy.optimize用于优化），其底层实现已优化截断误差，避免手动实现的缺陷。

舍入误差与截断误差的区别

特征

舍入误差（Round-off Error）

截断误差（Truncation Error）

产生原因

计算机有限精度存储（二进制表示限制）

有限次运算近似无限次运算（方法本身的近似）

影响因素

数值的有效位数、存储格式（如 float/double）

近似方法的阶数、迭代次数、步长等

变化趋势

随计算次数增加而累积（无法完全消除）

随近似复杂度提高而减小（可通过方法优化）

典型场景

浮点数加减、循环累积计算

泰勒级数、数值微分 / 积分、迭代算法
# python
Logo
AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

cover

Harness Engineering 深度解析

avatar AI Agent技术社区
cover

# Codex 与火山引擎 Agent：2026年AI Agent 开发平台深度对比与选型指南

avatar AI Agent技术社区
cover

agent面试必备53-AI Agent 终极考验：从 Demo 到生产环境的 5 大致命挑战

avatar AI Agent技术社区