这里的大多数答案都用非常枯燥的技术术语来解决这个问题。我想用正常人能够理解的方式来解决这个问题。

想象一下，你正试图把披萨切成薄片。你有一个机器人披萨切割机，可以将披萨切成两半。它可以将整个披萨减半，也可以将现有的披萨减半，但无论如何，减半总是准确的。

那台披萨切割机动作非常精细，如果你从一整块披萨开始，然后将其减半，然后继续每次将最小的披萨片减半，你可以在披萨片太小甚至无法实现高精度功能之前，将其减半53次。此时，您不能再将非常薄的切片减半，但必须按原样包含或排除它。

现在，你如何将所有的切片以这样一种方式分割，使其达到披萨的十分之一（0.1）或五分之一（0.2）？真的想一想，试着解决它。如果你手边有一个神话般的精密披萨切割机，你甚至可以尝试使用真正的披萨

---

当然，大多数有经验的程序员都知道真正的答案，那就是，无论你切得多细，都无法用这些切片拼凑出十分之一或五分之一的披萨。你可以做一个非常好的近似值，如果你把0.1的近似值和0.2的近似值相加，你会得到非常好的0.3的近似值。

对于双精度数字（允许您将披萨减半53次的精度），小于或大于0.1的数字分别为0.09999999999999999167332731531132594682276248931884765625和0.1000000000000000055511151231257827021181583404541015625。后者比前者更接近0.1，因此，如果输入值为0.1，数字解析器将倾向于后者。

（这两个数字之间的区别是“最小切片”，我们必须决定是否包含，这会引入向上的偏差，或者排除，这会带来向下的偏差。最小切片的技术术语是ulp。）

在0.2的情况下，数字都是相同的，只是放大了2倍。同样，我们赞成略高于0.2的值。

注意，在这两种情况下，0.1和0.2的近似值都有轻微的向上偏差。如果我们加上足够多的这些偏差，它们会将数字推离我们想要的越来越远，事实上，在0.1+0.2的情况下，偏差足够高，从而导致的数字不再是最接近0.3的数字。

特别是，0.1+0.2实际上是0.1000000000000000055511151231257827021181583404541015625+0.0200000000000000011102230246251565404236316680908203125=0.30000000000000000444089209850062616169452667236328125，而最接近0.3的数字实际上是0.29999999999988897769753748434595763683319091796875。

---

另外，一些编程语言还提供了披萨切割机，可以将披萨切成十分之一。虽然这种披萨切刀并不常见，但如果你有机会切到一个，那么你应该在切到十分之一或五分之一的披萨片非常重要的时候使用它。

（最初发布在Quora上。）

我刚刚看到了关于浮点数的有趣问题：

考虑以下结果：

error = (2**53+1) - int(float(2**53+1))

>>> (2**53+1) - int(float(2**53+1))
1

当2**53+1时，我们可以清楚地看到一个断点——直到2**53，所有的工作都正常。

>>> (2**53) - int(float(2**53))
0

发生这种情况的原因是双精度二进制：IEEE 754双精度二进制浮点格式：binary64

从维基百科的双精度浮点格式页面：

双精度二进制浮点是PC上常用的格式，因为它的范围比单精度浮点更广，尽管它的性能和带宽成本很高。与单精度浮点格式一样，与相同大小的整数格式相比，它缺少整数的精度。它通常简称为double。IEEE 754标准规定二进制64具有：符号位：1位指数：11位有效精度：53位（显式存储52位）具有给定偏置指数和52位分数的给定64位双精度数据假设的实际值为或

感谢@aguest向我指出了这一点。

从Python 3.5开始，您可以使用math.isclose（）函数来测试近似相等性：

>>> import math
>>> math.isclose(0.1 + 0.2, 0.3)
True
>>> 0.1 + 0.2 == 0.3
False

正常的算术是以10为基数的，所以小数表示十分、百分等。当你试图用二进制2为基数的算术表示浮点数时，你要处理的是半、四、八等。

在硬件中，浮点存储为整数尾数和指数。尾数表示有效数字。指数类似于科学记数法，但它使用的基数是2而不是10。例如，64.0将用尾数1和指数6表示。0.125将用尾数1和指数-3表示。

浮点小数必须加上2的负幂

0.1b = 0.5d
0.01b = 0.25d
0.001b = 0.125d
0.0001b = 0.0625d
0.00001b = 0.03125d

等等

在处理浮点运算时，通常使用误差增量而不是相等运算符。而不是

if(a==b) ...

你会使用

delta = 0.0001; // or some arbitrarily small amount
if(a - b > -delta && a - b < delta) ...

除了其他正确答案之外，您可能还需要考虑缩放值以避免浮点运算的问题。

例如：

var result = 1.0 + 2.0;     // result === 3.0 returns true

…而不是：

var result = 0.1 + 0.2;     // result === 0.3 returns false

在JavaScript中，表达式0.1+0.2===0.3返回false，但幸运的是，浮点中的整数运算是精确的，因此可以通过缩放来避免十进制表示错误。

作为一个实际的例子，为了避免精度至关重要的浮点问题，建议1将钱作为一个整数来处理：2550美分而不是25.50美元。

---

1 Douglas Crockford：JavaScript：好的部分：附录A——糟糕的部分（第105页）。

在硬件级别，浮点数表示为二进制数的分数（以2为基数）。例如，小数：

0.125

具有1/10+2/100+5/1000的值，并且以相同的方式，具有二进制分数：

0.001

值为0/2+0/4+1/8。这两个分数具有相同的值，唯一的区别是第一个是小数，第二个是二进制分数。

不幸的是，大多数十进制分数不能用二进制分数表示。因此，通常情况下，您给出的浮点数仅近似于存储在机器中的二进制分数。

这个问题在基础10中更容易解决。以分数1/3为例。您可以将其近似为小数：

0.3

或更好，

0.33

或更好，

0.333

无论你写了多少个小数点，结果永远不会精确到1/3，但这是一个总是更接近的估计。

同样，无论使用多少个以2为基数的小数位数，小数值0.1都不能精确地表示为二进制小数。在基数2中，1/10是以下周期数：

0.0001100110011001100110011001100110011001100110011 ...

停止在任何有限数量的比特，你会得到一个近似值。

对于Python，在典型的机器上，53位用于浮点的精度，因此输入小数0.1时存储的值是二进制小数。

0.00011001100110011001100110011001100110011001100110011010

其接近但不完全等于1/10。

很容易忘记存储的值是原始小数的近似值，因为在解释器中显示浮点的方式。Python只显示二进制存储值的十进制近似值。如果Python要输出存储为0.1的二进制近似值的真正十进制值，它将输出：

>>> 0.1
0.1000000000000000055511151231257827021181583404541015625

这比大多数人预期的小数位数要多得多，因此Python显示舍入值以提高可读性：

>>> 0.1
0.1

重要的是要理解，在现实中这是一种错觉：存储的值不完全是1/10，只是在显示器上存储的值被舍入。当您使用这些值执行算术运算时，这一点就会变得明显：

>>> 0.1 + 0.2
0.30000000000000004

这种行为是机器浮点表示的本质所固有的：它不是Python中的错误，也不是代码中的错误。你可以在所有其他语言中观察到相同类型的行为​​使用硬件支持计算浮点数（尽管有些语言​​默认情况下不使差异可见或在所有显示模式下不可见）。

另一个令人惊讶的地方就在这一点上。例如，如果尝试将值2.675舍入到两位小数，则会得到

>>> round (2.675, 2)
2.67

round（）原语的文档表明它舍入到离零最近的值。由于小数正好在2.67和2.68之间的一半，因此应该可以得到2.68（二进制近似值）。然而，情况并非如此，因为当小数2.675转换为浮点时，它由精确值为：

2.67499999999999982236431605997495353221893310546875

由于近似值比2.68略接近2.67，因此舍入值降低。

如果您处于小数向下舍入的情况，那么应该使用十进制模块。顺便说一下，十进制模块还提供了一种方便的方式来“查看”为任何浮点存储的确切值。

>>> from decimal import Decimal
>>> Decimal (2.675)
>>> Decimal ('2.67499999999999982236431605997495353221893310546875')

0.1不是精确存储在1/10中这一事实的另一个结果是十个值的总和​​0.1也不等于1.0：

>>> sum = 0.0
>>> for i in range (10):
... sum + = 0.1
...>>> sum
0.9999999999999999

二进制浮点数的算术有很多这样的惊喜。“0.1”的问题将在下文“表示错误”一节中详细解释。有关此类惊喜的更完整列表，请参阅浮点运算的危险。

确实没有简单的答案，但是不要对浮动虚拟数字过分怀疑！在Python中，浮点数操作中的错误是由底层硬件造成的，在大多数机器上，每次操作的错误率不超过1/2*53。这对于大多数任务来说都是非常必要的，但您应该记住，这些操作不是十进制操作，并且对浮点数字的每一次操作都可能会出现新的错误。

尽管存在病态的情况，但对于大多数常见的用例，您只需在显示器上舍入到所需的小数位数，就可以在最后得到预期的结果。有关如何显示浮点数的详细控制，请参阅字符串格式语法以了解str.format（）方法的格式规范。

答案的这一部分详细解释了“0.1”的示例，并展示了如何自己对此类案例进行精确分析。我们假设您熟悉浮点数的二进制表示。术语表示错误意味着大多数小数不能用二进制精确表示。这就是为什么Python（或Perl、C、C++、Java、Fortran等）通常不会以十进制显示精确结果的主要原因：

>>> 0.1 + 0.2
0.30000000000000004

为什么？1/10和2/10不能用二进制分数精确表示。然而，今天（2010年7月）所有的机器都遵循IEEE-754标准来计算浮点数。大多数平台使用“IEEE-754双精度”来表示Python浮点。双精度IEEE-754使用53位精度，因此在读取时，计算机尝试将0.1转换为J/2*N形式的最接近分数，J正好是53位的整数。重写：

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

in :

J ~ = 2 ** N / 10

记住J正好是53位（所以>=2**52但<2**53），N的最佳可能值是56:

>>> 2 ** 52
4503599627370496
>>> 2 ** 53
9007199254740992
>>> 2 ** 56/10
7205759403792793

因此，56是N的唯一可能值，正好为J保留53位。因此，J的最佳可能值是这个商，四舍五入：

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

由于进位大于10的一半，通过四舍五入获得最佳近似值：

>>> q + 1
7205759403792794

因此，“IEEE-754双精度”中1/10的最佳近似值为2**56以上，即：

7205759403792794/72057594037927936

注意，由于四舍五入是向上进行的，结果实际上略大于1/10；如果我们没有四舍五入，这个商会略小于1/10。但无论如何都不是1/10！

因此，计算机从未“看到”1/10：它看到的是上面给出的精确分数，这是使用“IEEE-754”中的双精度浮点数的最佳近似值：

>>>. 1 * 2 ** 56
7205759403792794.0

如果我们将这个分数乘以10**30，我们可以观察到这些值​​它的30位小数具有很强的权重。

>>> 7205759403792794 * 10 ** 30 // 2 ** 56
100000000000000005551115123125L

这意味着存储在计算机中的精确值近似等于十进制值0.100000000000000005551115123125。在Python 2.7和Python 3.1之前的版本中，Python舍入这些值​​到17位有效小数，显示“0.10000000000000001”。在当前版本的Python中，显示的值是分数尽可能短的值，当转换回二进制时，给出的表示形式完全相同，只需显示“0.1”。