Question

每个人都知道，或者至少every programmers should know，使用float类型会导致精确错误。但是，在某些情况下，确切的解决方案会很好，并且有些情况下使用epsilon值进行比较是不够的。无论如何，这不是重点。

我知道Python中的Decimal类型，但从未尝试过使用它。它声明"Decimal numbers can be represented exactly"我认为它意味着一个聪明的实现，允许代表任何实数。我的第一次尝试是：

>>> from decimal import Decimal
>>> d = Decimal(1) / Decimal(3)
>>> d3 = d * Decimal(3)
>>> d3 < Decimal(1)
True

非常失望，我回到文档并继续阅读：

算术的上下文是指定精度[...]
的环境

好的，所以实际上有一个精确度。经典问题可以再现：

>>> dd = d * 10**20
>>> dd
Decimal('33333333333333333333.33333333')
>>> for i in range(10000):
...    dd += 1 / Decimal(10**10)
>>> dd
Decimal('33333333333333333333.33333333')

所以，我的问题是：有没有办法让Decimal类型具有无限精度？如果不是，那么比较2个十进制数的更优雅的方法是什么（例如，如果delta小于精度，则d3＆lt; 1应返回False。）

目前，当我只进行分割和乘法时，我使用Fraction类型：

>>> from fractions import Fraction
>>> f = Fraction(1) / Fraction(3)
>>> f
Fraction(1, 3)
>>> f * 3 < 1
False
>>> f * 3 == 1
True

这是最好的方法吗？还有什么其他选择？

Answer 1

Decimal类最适用于财务类型加法，减法乘法，除法类型问题：

>>> (1.1+2.2-3.3)*10000000000000000000
4440.892098500626                            # relevant for government invoices...
>>> import decimal
>>> D=decimal.Decimal
>>> (D('1.1')+D('2.2')-D('3.3'))*10000000000000000000
Decimal('0.0')

Fraction模块适用于您描述的有理数问题域：

>>> from fractions import Fraction
>>> f = Fraction(1) / Fraction(3)
>>> f
Fraction(1, 3)
>>> f * 3 < 1
False
>>> f * 3 == 1
True

对于科学工作的纯多精度浮点，请考虑mpmath。

如果您的问题可以保留在符号领域，请考虑sympy。以下是处理1/3问题的方法：

>>> sympy.sympify('1/3')*3
1
>>> (sympy.sympify('1/3')*3) == 1
True

Sympy使用mpmath作为任意精度浮点，包括象征性地处理有理数和无理数的能力。

考虑√2：

的无理值的纯浮点表示

>>> math.sqrt(2)
1.4142135623730951
>>> math.sqrt(2)*math.sqrt(2)
2.0000000000000004
>>> math.sqrt(2)*math.sqrt(2)==2
False

与sympy比较：

>>> sympy.sqrt(2)
sqrt(2)                              # treated symbolically
>>> sympy.sqrt(2)*sympy.sqrt(2)==2
True

您还可以减少值：

>>> import sympy
>>> sympy.sqrt(8)
2*sqrt(2)                            # √8 == √(4 x 2) == 2*√2...

但是，如果不小心，你可以看到Sympy的问题类似于直接浮点：

>>> 1.1+2.2-3.3
4.440892098500626e-16
>>> sympy.sympify('1.1+2.2-3.3')
4.44089209850063e-16                   # :-(

最好使用Decimal：

>>> D('1.1')+D('2.2')-D('3.3')
Decimal('0.0')

或使用“分数”或“Sympy”并将1.1等值保留为比率：

>>> sympy.sympify('11/10+22/10-33/10')==0
True
>>> Fraction('1.1')+Fraction('2.2')-Fraction('3.3')==0
True

或者在同情中使用Rational：

>>> frac=sympy.Rational
>>> frac('1.1')+frac('2.2')-frac('3.3')==0
True
>>> frac('1/3')*3
1

您可以使用sympy live。

Answer 2

所以，我的问题是：有没有办法让Decimal类型具有无限精度？

不，因为存储无理数会需要无限的内存。

Decimal有用的地方是货币金额，货币金额必须精确且先验已知精确度。

从问题来看，Decimal比float更适合您的用例并不完全清楚。

Answer 3

有没有办法让Decimal类型具有无限精度？

没有;对于实线上的任何非空间隔，您不能使用有限位数表示具有无限精度的集合中的所有数字。这就是Fraction有用的原因，因为它将分子和分母存储为整数，可以精确表示：

>>> Fraction("1.25")
Fraction(5, 4)

Answer 4

如果您是Decimal的新手，则此帖子相关：Python floating point arbitrary precision available?

答案和评论的基本思想是，对于需要精确度的计算难度较大的问题，您应该使用mpmath模块https://code.google.com/p/mpmath/。一个重要的观察是，

使用十进制数字的问题在于你在十进制对象上的数学函数方面做不了多少

Answer 5

只是指出一些可能不会对每个人都立即显而易见的事情：

decimal 模块的 documentation 说明

<块引用>

... 精确性延续到算术中。在十进制浮点数中，0.1 + 0.1 + 0.1 - 0.3 正好等于零。

（另见经典：Is floating point math broken?）

然而，如果我们使用 decimal.Decimal 天真，我们会得到同样的“意外”结果

>>> Decimal(0.1) + Decimal(0.1) + Decimal(0.1) == Decimal(0.3)
False

上面这个简单示例中的问题是使用了 float 参数，如 docs 中所述，这些参数“无损地转换为 [他们的] 精确十进制等效值”。

技巧（隐含在接受的答案中）是使用例如构造 Decimal 实例字符串，而不是浮点数

>>> Decimal('0.1') + Decimal('0.1') + Decimal('0.1') == Decimal('0.3')
True

或者，在某些情况下可能更方便，使用元组 (<sign>, <digits>, <exponent>)

>>> Decimal((0, (1,), -1)) + Decimal((0, (1,), -1)) + Decimal((0, (1,), -1)) == Decimal((0, (3,), -1))
True

注意：这并没有回答原始问题，但它是密切相关的，并且可能对根据问题标题最终到达这里的人有所帮助。

澄清Python中的Decimal类型

5 个答案: