15. 浮点数算术：问题和限制

浮点数在计算机硬件中以 2 为底（二进制）的分数形式表示。例如，**十进制**小数 0.625 的值为 6/10 + 2/100 + 5/1000，同样地，**二进制**小数 0.101 的值为 1/2 + 0/4 + 1/8。这两个小数的值相同，唯一的真正区别是第一个以 10 为底的小数表示法书写，第二个以 2 为底书写。

不幸的是，大多数十进制小数不能精确地表示为二进制小数。一个结果是，通常，您输入的十进制浮点数只是近似于实际存储在机器中的二进制浮点数。

这个问题最初在以 10 为底的情况下更容易理解。考虑分数 1/3。您可以将其近似为以 10 为底的分数

0.3

或者，更好的是，

0.33

或者，更好的是，

0.333

等等。无论您愿意写下多少位数字，结果永远不会完全是 1/3，而是越来越接近 1/3 的近似值。

同样，无论您愿意使用多少个以 2 为底的数字，十进制值 0.1 都无法精确地表示为以 2 为底的分数。在以 2 为底的情况下，1/10 是无限重复的小数

0.0001100110011001100110011001100110011001100110011...

在任意有限的位数处停止，您都会得到一个近似值。在当今大多数机器上，浮点数使用二进制分数来近似，其中分子使用从最高有效位开始的前 53 位，分母为 2 的幂。在 1/10 的情况下，二进制分数为 3602879701896397 / 2 ** 55，它接近但不完全等于 1/10 的真实值。

许多用户没有意识到这种近似，因为值的显示方式。Python 只打印机器存储的二进制近似值的真实十进制值的十进制近似值。在大多数机器上，如果 Python 要打印为 0.1 存储的二进制近似值的真实十进制值，它将必须显示

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

这比大多数人认为有用的数字多，因此 Python 通过显示舍入值来保持数字的可管理性

>>> 1 / 10
0.1

请记住，即使打印的结果看起来像 1/10 的精确值，但实际存储的值是最接近的可表示二进制分数。

有趣的是，有许多不同的十进制数共享相同的最接近近似二进制分数。例如，数字 0.1 和 0.10000000000000001 和 0.1000000000000000055511151231257827021181583404541015625 都近似于 3602879701896397 / 2 ** 55。由于所有这些十进制值都共享相同的近似值，因此可以显示其中任何一个值，同时仍然保持不变 eval(repr(x)) == x。

历史上，Python 提示符和内置的 repr() 函数会选择具有 17 位有效数字的 0.10000000000000001。从 Python 3.1 开始，Python（在大多数系统上）现在能够选择其中最短的一个并简单地显示 0.1。

请注意，这是二进制浮点数的本质：这不是 Python 中的错误，也不是您代码中的错误。您将在所有支持硬件浮点运算的语言中看到同样的情况（尽管某些语言可能默认不 *显示* 差异，或者在所有输出模式中）。

为了获得更令人愉悦的输出，您可能希望使用字符串格式来生成有限数量的有效数字

>>> format(math.pi, '.12g')  # give 12 significant digits
'3.14159265359'

>>> format(math.pi, '.2f')   # give 2 digits after the point
'3.14'

>>> repr(math.pi)
'3.141592653589793'

重要的是要意识到，这在某种意义上是一种错觉：您只是在对真实机器值的 *显示* 进行舍入。

一种错觉可能会导致另一种错觉。例如，由于 0.1 不完全等于 1/10，因此将三个 0.1 的值相加也可能不会精确地产生 0.3

>>> 0.1 + 0.1 + 0.1 == 0.3
False

此外，由于 0.1 不能更接近 1/10 的精确值，并且 0.3 不能更接近 3/10 的精确值，因此使用 round() 函数进行预舍入也无济于事

>>> round(0.1, 1) + round(0.1, 1) + round(0.1, 1) == round(0.3, 1)
False

虽然这些数字不能更接近其预期的精确值，但 math.isclose() 函数可用于比较不精确的值

>>> math.isclose(0.1 + 0.1 + 0.1, 0.3)
True

或者，可以使用 round() 函数来比较粗略的近似值

>>> round(math.pi, ndigits=2) == round(22 / 7, ndigits=2)
True

二进制浮点算术会带来许多这样的惊喜。“0.1” 的问题在下面的“表示误差”部分中进行了精确的详细解释。请参阅 浮点问题示例，了解二进制浮点数的工作原理以及实践中常见的各种问题的简明总结。另请参阅 浮点的危险，了解其他常见意外情况的更完整说明。

正如最后所说，“没有简单的答案”。尽管如此，不要对浮点数过于警惕！Python 浮点运算中的误差是从浮点硬件继承的，在大多数机器上，每次运算的误差不超过 1/2**53。这对于大多数任务来说绰绰有余，但您确实需要记住，这不是十进制算术，并且每次浮点运算都可能遭受新的舍入误差。

虽然确实存在病理情况，但对于大多数浮点算术的随意使用，如果您只是将最终结果的显示舍入到您期望的十进制位数，您最终会看到您期望的结果。str() 通常就足够了，而对于更精细的控制，请参阅 str.format() 方法在 格式字符串语法 中的格式说明符。

对于需要精确十进制表示的用例，请尝试使用 decimal 模块，该模块实现适用于会计应用程序和高精度应用程序的十进制算术。

另一种精确算术形式由 fractions 模块支持，该模块实现基于有理数的算术（因此像 1/3 这样的数字可以精确表示）。

如果您是浮点运算的重度用户，您应该查看 NumPy 包以及 SciPy 项目提供的许多其他用于数学和统计运算的包。请参阅 <https://scipy.org.cn>。

Python 提供了工具，可以在那些罕见的情况下帮助您真正 *想* 知道浮点数的精确值。float.as_integer_ratio() 方法将浮点数的值表示为分数

>>> x = 3.14159
>>> x.as_integer_ratio()
(3537115888337719, 1125899906842624)

由于该比率是精确的，因此可以无损地重新创建原始值

>>> x == 3537115888337719 / 1125899906842624
True

float.hex() 方法以十六进制（以 16 为底）表示浮点数，再次给出计算机存储的精确值

>>> x.hex()
'0x1.921f9f01b866ep+1'

这种精确的十六进制表示可以用于精确地重建浮点数值

>>> x == float.fromhex('0x1.921f9f01b866ep+1')
True

由于表示是精确的，因此它对于在不同版本的 Python 之间可靠地移植值（平台独立性）以及与其他支持相同格式的语言（例如 Java 和 C99）交换数据非常有用。

另一个有用的工具是 sum() 函数，该函数有助于减轻求和期间的精度损失。它在将值添加到运行总计时，对中间舍入步骤使用扩展精度。这可能会对整体准确性产生影响，因此误差不会累积到影响最终总和的程度

>>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0
False
>>> sum([0.1] * 10) == 1.0
True

math.fsum() 更进一步，它在将值添加到运行总计时跟踪所有“丢失的数字”，因此结果只有一个舍入。这比 sum() 慢，但在大型输入相互抵消导致最终总和接近于零的罕见情况下会更准确

>>> arr = [-0.10430216751806065, -266310978.67179024, 143401161448607.16,
...        -143401161400469.7, 266262841.31058735, -0.003244936839808227]
>>> float(sum(map(Fraction, arr)))   # Exact summation with single rounding
8.042173697819788e-13
>>> math.fsum(arr)                   # Single rounding
8.042173697819788e-13
>>> sum(arr)                         # Multiple roundings in extended precision
8.042178034628478e-13
>>> total = 0.0
>>> for x in arr:
...     total += x                   # Multiple roundings in standard precision
...
>>> total                            # Straight addition has no correct digits!
-0.0051575902860057365

15.1. 表示误差

本节将详细解释“0.1”的示例，并展示如何自行对类似情况进行精确分析。假设您已基本熟悉二进制浮点数表示法。

表示误差是指某些（实际上是大多数）十进制小数无法精确地表示为二进制（以 2 为底）小数。这是 Python（或 Perl、C、C++、Java、Fortran 以及许多其他语言）通常无法显示您期望的精确十进制数的主要原因。

这是为什么呢？1/10 无法精确地表示为二进制小数。自 2000 年以来，几乎所有机器都使用 IEEE 754 二进制浮点算术，并且几乎所有平台都将 Python 的浮点数映射到 IEEE 754 binary64 “双精度”值。IEEE 754 binary64 值包含 53 位精度，因此在输入时，计算机会尽力将 0.1 转换为最接近的 J/2**N 形式的分数，其中 J 是一个正好包含 53 位的整数。重写

1 / 10 ~= J / (2**N)

为

J ~= 2**N / 10

并回顾 J 正好有 53 位（即 >= 2**52 但 < 2**53），N 的最佳值是 56

>>> 2**52 <=  2**56 // 10  < 2**53
True

也就是说，56 是唯一能使 J 正好有 53 位的 N 值。J 的最佳值是该商的舍入值

>>> q, r = divmod(2**56, 10)
>>> r
6

由于余数大于 10 的一半，因此通过向上舍入获得最佳近似值

>>> q+1
7205759403792794

因此，IEEE 754 双精度中 1/10 的最佳近似值是

7205759403792794 / 2 ** 56

分子和分母都除以 2 可以将分数简化为

3602879701896397 / 2 ** 55

请注意，由于我们向上舍入，这实际上比 1/10 略大；如果我们没有向上舍入，商将略小于 1/10。但无论如何它都不可能正好是 1/10！

因此，计算机永远不会“看到” 1/10：它看到的是上面给出的精确分数，这是它可以获得的 IEEE 754 双精度的最佳近似值

>>> 0.1 * 2 ** 55
3602879701896397.0

如果我们将该分数乘以 10**55，我们可以看到该值到 55 位小数

>>> 3602879701896397 * 10 ** 55 // 2 ** 55
1000000000000000055511151231257827021181583404541015625

这意味着存储在计算机中的确切数字等于十进制值 0.1000000000000000055511151231257827021181583404541015625。许多语言（包括旧版本的 Python）不是显示完整的十进制值，而是将结果四舍五入为 17 位有效数字

>>> format(0.1, '.17f')
'0.10000000000000001'

fractions 和 decimal 模块使这些计算变得容易

>>> from decimal import Decimal
>>> from fractions import Fraction

>>> Fraction.from_float(0.1)
Fraction(3602879701896397, 36028797018963968)

>>> (0.1).as_integer_ratio()
(3602879701896397, 36028797018963968)

>>> Decimal.from_float(0.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')

>>> format(Decimal.from_float(0.1), '.17')
'0.10000000000000001'