15. 浮点算术：问题与限制

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

不幸的是，大多数十进制分数不能精确地表示为二进制分数。结果是，通常情况下，您输入的十进制浮点数只能由机器中实际存储的二进制浮点数来近似表示。

这个问题首先以 10 为基数更容易理解。考虑分数 1/3。您可以将其近似为十进制分数

0.3

或者，更好的是，

0.33

或者，更好的是，

0.333

等等。无论您愿意写多少位数字，结果都不会是精确的 1/3，但会是 1/3 的越来越好的近似值。

同样地，无论您愿意使用多少个二进制位，十进制值 0.1 都不能精确地表示为二进制分数。在二进制中，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 的 bug，也不是您代码的 bug。在所有支持您硬件浮点算术的语言中，您都会看到类似的情况（尽管某些语言可能默认不**显示**差异，或者在所有输出模式下都不显示）。

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

>>> 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 浮点运算中的误差继承自浮点硬件，在大多数机器上，每次运算的误差不超过 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)

as

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

分子和分母同时除以二，将分数简化为

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'