十进制固定精度

Question

我想在货币计算中使用十进制，所以我想在逗号之后处理两个数字。最初，我认为十进制上下文的prec指的是这个属性，但经过几次实验后，我感到有点困惑。

实验1：

In [1]: import decimal                                                                                                                      

In [2]: decimal.getcontext().prec = 2                                                                                                       

In [3]: a = decimal.Decimal('159.9')                                                                                                        

In [4]: a                                                                                                                                   
Out[4]: Decimal('159.9')

In [5]: b = decimal.Decimal('200')                                                                                                          

In [6]: b                                                                                                                                   
Out[6]: Decimal('200')

In [7]: b - a                                                                                                                               
Out[7]: Decimal('40')

实验2：

In [8]: decimal.getcontext().prec = 4                                                                                                       

In [9]: a = decimal.Decimal('159.9')                                                                                                        

In [10]: a                                                                                                                                  
Out[10]: Decimal('159.9')

In [11]: b = decimal.Decimal('200')                                                                                                         

In [12]: b                                                                                                                                  
Out[12]: Decimal('200')

In [13]: b - a                                                                                                                              
Out[13]: Decimal('40.1')

实验3： (prec仍然设置为4)

In [14]: a = decimal.Decimal('159999.9')                                                                                                    

In [15]: a                                                                                                                                  
Out[15]: Decimal('159999.9')

In [16]: b = decimal.Decimal('200000')                                                                                                      

In [17]: b                                                                                                                                  
Out[17]: Decimal('200000')

In [18]: b - a                                                                                                                              
Out[18]: Decimal('4.000E+4')

为什么它在我的例子中起作用呢？在我的(货币计算)情况下，我应该如何处理小数？

Answer 1

精度设置有效位数，这与小数点之后的数字数不相等。

因此，如果您的精度为2，您将有两个有效数字，因此，一个具有3个重要数字(如40.1 )的数字将被简化为给出40的上两个重要数字。

用Decimal设置小数点后的位数没有一种简单的方法。但是，您可以使用高精度，并且总是将结果round为两个小数：

>>> from decimal import Decimal, getcontext
>>> getcontext().prec = 60  # use a higher/lower one if needed
>>> Decimal('200') - Decimal('159.9')
Decimal('40.1')
>>> r = Decimal('200') - Decimal('159.9')
>>> round(r, 2)
Decimal('40.10')

十进制常见问题还包括一个类似的问题和答案(使用quantize)：

在有两个小数位的定点应用程序中，有些输入有很多位，需要舍入。其他的则不应该有多余的数字，需要验证。应该使用什么方法？ 量化()方法循环到一个固定的小数位数。如果设置了不精确的陷阱，它对于验证也是有用的：TWOPLACES = Decimal(10) ** -2 #与十进制(‘0.01’) >>> #圆相同，>>> Decimal(‘3.214’).quantize(‘3.214’)十进制(‘3.21’) >>> #验证一个数字不超过两个位置>>> Decimal('3.21') .quantize(‘3.21’，context=Context(traps=Inexact)) Decimal('3.21') >>> Decimal('3.214').quantize(TWOPLACES，context=Context(traps=Inexact))追踪(最近一次调用)：不准确:无 一旦我有了有效的两个位置输入，我如何在整个应用程序中保持不变？ 一些运算，如加、减、乘一个整数，将自动保持不动点。其他操作，如除法和非整数乘法，将改变小数位数，并需要后续使用quantize()步骤： A=十进制(‘102.72’)#初始定点值>>> b=十进制(‘3.17’) >>> a+b#加法保留定点十进制(‘105.89’) >>> a-b十进制(‘99.55’) >>> a* 42 #整数乘法十进制(‘4314.24’) >>> (a * b).quantize(TWOPLACES)#必须量化非整数乘法十进制(‘325.62’) >>> (b / a).quantize(TWOPLACES) #和量化除法十进制(‘0.03’) 在开发定点应用程序时，可以方便地定义函数来处理quantize()步骤： def mul(x，y，fp=TWOPLACES)：返回(x * y).quantize(fp) >>> def div(x，y，fp=TWOPLACES)：.返回(x / y).quantize(fp) >>> mul(a，b) #自动保持定点十进制(‘325.62’) >>> div(b，a)十进制(‘0.03’)

Answer 2

我发现的最佳方法是设置一个较高的prec，并使用Decimal.quantize对结果进行舍入：

decimal.getcontext().prec=100
a = Decimal('400000.123456789')
b = Decimal('200000.0')
a-b
>>> Decimal('2.0000E+5')
(a-b).quantize(Decimal('0.01'))
>>> Decimal('200000.12')