decimal – 十进制定点和浮点运算详解 (4) Python语言的数学和数学模块(必读进阶学习教程)(参考资料)

十进制对象

类decimal.Decimal（值=“0”，上下文=无）

Decimal根据value构造一个新对象。

值可以是整数、字符串、元组float、 或其他Decimal 对象。如果没有给出值，则返回Decimal('0')。如果value是一个字符串，在删除前导和尾随空白字符以及整个下划线后，它应该符合十进制数字字符串语法：

sign           ::=  '+' | '-'
digit          ::=  '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9'
indicator      ::=  'e' | 'E'
digits         ::=  digit [digit]...
decimal-part   ::=  digits '.' [digits] | ['.'] digits
exponent-part  ::=  indicator [sign] digits
infinity       ::=  'Infinity' | 'Inf'
nan            ::=  'NaN' [digits] | 'sNaN' [digits]
numeric-value  ::=  decimal-part [exponent-part] | infinity
numeric-string ::=  [sign] numeric-value | [sign] nan

上面出现的其他 Unicode 十进制数字也是允许digit 的。这些包括来自各种其他字母表的十进制数字（例如，Arabic-Indic 和 Devanāgarī 数字）以及全角数字'\uff10'到'\uff19'.

如果value是 a tuple，它应该有三个组成部分，一个符号（0正号或1负号），一个tuple数字和一个整数指数。例如， 返回.Decimal((0, (1, 4, 1, 4), -3))Decimal('1.414')

如果value是 a float，则二进制浮点值将无损地转换为其精确的十进制等效值。这种转换通常需要 53 位或更多位的精度。例如，Decimal(float('1.1')) 转换为 Decimal('1.100000000000000088817841970012523233890533447265625').

上下文精度不影响存储的位数。这完全由value中的位数决定。例如， Decimal('3.00000')即使上下文精度仅为三，也记录所有五个零。

context参数的目的是确定如果value是格式错误的字符串该怎么做。如果上下文陷入困境InvalidOperation，则会引发异常；否则，构造函数返回一个值为 的新 Decimal NaN。

一旦构建，Decimal对象就是不可变的。

在 3.2 版更改:现在允许构造函数的参数是一个float 实例。

在 3.3 版更改：如果 设置了陷阱，则float参数会引发异常。FloatOperation默认情况下，陷阱处于关闭状态。

在 3.6 版更改：允许使用下划线进行分组，就像代码中的整数和浮点文字一样。

十进制浮点对象与其他内置数字类型（例如float和）共享许多属性int。所有常用的数学运算和特殊方法都适用。同样，小数对象可以被复制、腌制、打印、用作字典键、用作集合元素、比较、排序和强制转换为另一种类型（例如float或 int）。

Decimal 对象的算术与整数和浮点数的算术之间存在一些细微差别。当余数运算符%应用于 Decimal 对象时，结果的符号是 被除数的符号而不是除数的符号：

>>> (-7) % 4
1
>>> Decimal(-7) % Decimal(4)
Decimal('-3')

整数除法运算符的//行为类似，返回真商的整数部分（截断为零）而不是它的底数，以保持通常的身份：x == (x // y) * y + x % y

>>> -7 // 4
-2
>>> Decimal(-7) // Decimal(4)
Decimal('-1')

%and运算符（分别）按照规范中的描述实现//andremainder操作 。divide-integer

Decimal 对象通常不能与fractions.Fraction算术运算中的浮点数或实例组合：例如，尝试将 a 添加Decimal到 afloat将引发 a TypeError。但是，可以使用 Python 的比较运算符将一个Decimal 实例x与另一个数字进行比较y。这避免了在不同类型的数字之间进行相等比较时混淆结果。

在 3.2 版更改：Decimal现在完全支持实例和其他数字类型之间的混合类型比较。

除了标准的数字属性，十进制浮点对象还有一些专门的方法：

adjusted( ) 

在移出系数最右边的数字直到只剩下前导数字后返回调整后的指数： Decimal('321e+5').adjusted()返回 7。用于确定最高有效位相对于小数点的位置。

as_integer_ratio( ) 

返回一对整数，将给定 实例表示为分数，以最小项表示并具有正分母：(n, d)Decimal

>>> Decimal('-3.14').as_integer_ratio()
(-157, 50)

转换是准确的。引发无穷大的 OverflowError 和 NaN 的 ValueError。

3.6 版中的新功能。

as_tuple( ) 

返回数字的命名元组表示形式： 。DecimalTuple(sign, digits, exponent)

canonical( ) 

返回参数的规范编码。目前，Decimal实例的编码始终是规范的，因此此操作返回其参数不变。

compare(other, context=None)

比较两个 Decimal 实例的值。 compare()返回一个 Decimal 实例，如果任一操作数为 NaN，则结果为 NaN：

a or b is a NaN  ==> Decimal('NaN')
a < b            ==> Decimal('-1')
a == b           ==> Decimal('0')
a > b            ==> Decimal('1')

compare_signal(other, context=None)

此操作与compare()方法相同，除了所有 NaN 信号。也就是说，如果两个操作数都不是信号 NaN，则任何安静的 NaN 操作数都被视为信号 NaN。

compare_total(other, context=None)

使用它们的抽象表示而不是它们的数值来比较两个操作数。 类似于 compare() 方法，但结果给出了 Decimal 实例的总排序。 具有相同数值但不同表示的两个 Decimal 实例在此排序中比较不相等：

>>> Decimal('12.0').compare_total(Decimal('12'))
Decimal('-1')

安静和信号 NaN 也包含在总排序中。 如果两个操作数具有相同的表示，则此函数的结果为 Decimal(‘0’)，如果第一个操作数在总顺序上低于第二个，则为 Decimal(‘-1’)，如果 第一个操作数在总顺序上高于第二个操作数。 有关总订单的详细信息，请参阅规范。

此操作不受上下文影响并且是安静的：没有更改标志，也没有执行舍入。 作为例外，如果无法准确转换第二个操作数，C 版本可能会引发 InvalidOperation。

compare_total_mag(other, context=None)

使用它们的抽象表示而不是它们的值来比较两个操作数compare_total()，但忽略每个操作数的符号。 x.compare_total_mag(y)相当于 x.copy_abs().compare_total(y.copy_abs()).

此操作不受上下文影响并且是安静的：没有更改标志，也没有执行舍入。作为例外，如果无法准确转换第二个操作数，C 版本可能会引发 InvalidOperation。

conjugate( ) 

Just returns self，此方法仅符合Decimal Specification。

copy_abs( ) 

返回参数的绝对值。此操作不受上下文影响并且是安静的：没有更改标志，也没有执行舍入。

copy_negate( ) 

返回参数的否定。此操作不受上下文影响并且是安静的：没有更改标志，也没有执行舍入。

copy_sign(other, context=None)

返回第一个操作数的副本，其符号设置为与第二个操作数的符号相同。例如：

>>> Decimal('2.3').copy_sign(Decimal('-1.5'))
Decimal('-2.3')

此操作不受上下文影响并且是安静的：没有更改标志，也没有执行舍入。作为例外，如果无法准确转换第二个操作数，C 版本可能会引发 InvalidOperation。

exp(context=None)

返回给定数字处的（自然）指数函数e**x的值。使用 ROUND_HALF_EVEN舍入模式正确舍入结果。

>>> Decimal(1).exp()
Decimal('2.718281828459045235360287471')
>>> Decimal(321).exp()
Decimal('2.561702493119680037517373933E+139')

from_float(f)

将浮点数准确地转换为十进制数的类方法。

注意Decimal.from_float(0.1)与Decimal(‘0.1’)不同。由于 0.1 不能用二进制浮点数精确表示，因此该值存储为最接近的可表示值，即 0x1.999999999999ap-4。十进制的等效值是 0.1000000000000000055511151231257827021181583404541015625。

>>> Decimal.from_float(0.1)
Decimal('0.1000000000000000055511151231257827021181583404541015625')
>>> Decimal.from_float(float('nan'))
Decimal('NaN')
>>> Decimal.from_float(float('inf'))
Decimal('Infinity')
>>> Decimal.from_float(float('-inf'))
Decimal('-Infinity')

fma(other, third, context=None)

融合乘加。返回 self*other+third 中间产品 self*other 没有四舍五入。

>>> Decimal(2).fma(3, 5)
Decimal('11')

is_canonical( ) 

如果参数是规范的则返回True， 否则返回False。目前，一个Decimal实例总是规范的，所以这个操作总是返回True。

is_finite( ) 

如果参数是有限数，则返回 True；如果参数是无穷大或 NaN，则返回 False。

is_infinite( ) 

如果参数是正无穷大或负无穷大，则返回 True，否则返回 False。

is_nan( ) 

如果参数是（安静的或发信号的）NaN，则返回 True，否则返回 False。

is_normal(context=None)

如果参数是正常的有限数，则返回 True。 如果参数为零、次正规、无限或 NaN，则返回 False。

is_qnan( ) 

如果参数是一个安静的 NaN，则返回 True，否则返回 False。

is_signed( ) 

如果参数有负号则返回 True，否则返回 False。 请注意，零和 NaN 都可以带符号。

is_snan( ) 

如果参数是信号 NaN 则返回 True，否则返回 False。

is_subnormal(context=None)

如果参数是次正规的，则返回 True，否则返回 False。

is_zero( ) 

如果参数是（正或负）零，则返回 True，否则返回 False。

ln(context=None)

返回操作数的自然（以 e 为底）对数。 结果使用 ROUND_HALF_EVEN 舍入模式正确舍入。

log10(context=None)

返回操作数的以十为底的对数。使用ROUND_HALF_EVEN舍入模式正确舍入结果。

logb(context=None)

对于非零数，将其操作数的调整指数作为 Decimal 实例返回。 如果操作数为零，则返回 Decimal(‘-Infinity’) 并引发 DivisionByZero 标志。 如果操作数是无穷大，则返回 Decimal(‘Infinity’)。

logical_and(other, context=None)

logical_and() 是一个逻辑运算，需要两个逻辑操作数（请参阅逻辑操作数）。 结果是两个操作数的数字和。

logical_invert(context=None)

logical_invert()是逻辑运算。结果是操作数的数字反转。

logical_or(other, context=None)

logical_or()是一个逻辑运算，需要两个逻辑操作数（请参阅逻辑操作数）。结果是or两个操作数的数字方式。

logical_xor(other, context=None)

logical_xor()是一个逻辑运算，需要两个逻辑操作数（请参阅逻辑操作数）。结果是两个操作数的数字异或。

max(other, context=None)

与 max(self, other) 一样，除了在返回之前应用上下文舍入规则并且 NaN 值被发出信号或被忽略（取决于上下文以及它们是发出信号还是静默）。

max_mag(other, context=None)

与max()方法类似，但比较是使用操作数的绝对值完成的。

min(other, context=None)

与 min(self, other) 类似，除了在返回之前应用上下文舍入规则并且 NaN 值被发出信号或被忽略（取决于上下文以及它们是发出信号还是静默）。

min_mag(other, context=None)

与min()方法类似，但比较是使用操作数的绝对值完成的。

next_minus(context=None)

返回在给定上下文中（如果没有给出上下文，则在当前线程的上下文中）可表示的小于给定操作数的最大数字。

next_plus(context=None)

返回在给定上下文中（如果没有给出上下文，则在当前线程的上下文中）可表示的大于给定操作数的最小数字。

next_toward(other, context=None)

如果两个操作数不相等，则返回在第二个操作数的方向上最接近第一个操作数的数。如果两个操作数在数值上相等，则返回第一个操作数的副本，其符号设置为与第二个操作数的符号相同。

normalize(context=None)

通过去除最右边的尾随零并将任何结果转换为等于来规范化Decimal('0')数字 Decimal('0e0')。用于为等价类的属性生成规范值。例如，Decimal('32.100')和 Decimal('0.321000e+2')都归一化为等效值 Decimal('32.1')。

number_class(context=None)

返回描述操作数类的字符串。返回值为以下十个字符串之一。

• "-Infinity"，表示操作数为负无穷大。
• "-Normal"，表示操作数是负正规数。
• "-Subnormal"，表示操作数为负且次正规。
• "-Zero"，表示操作数为负零。
• "+Zero"，表示操作数为正零。
• "+Subnormal"，表示操作数为正且次正规。
• "+Normal", 表示操作数是正正规数。
• "+Infinity"，表示操作数为正无穷大。
• "NaN"，表示操作数是一个安静的 NaN（非数字）。
• "sNaN"，表示操作数是一个信号 NaN。

quantize( exp , rounding=None , context=None ) 

在四舍五入后返回一个等于第一个操作数并具有第二个操作数的指数的值。

>>> Decimal('1.41421356').quantize(Decimal('1.000'))
Decimal('1.414')

与其他操作不同，如果量化操作后系数的长度大于精度，则 InvalidOperation发出信号。这保证了除非出现错误情况，否则量化指数始终等于右侧操作数的指数。

与其他操作不同的是，量化从不发出下溢信号，即使结果不正常且不准确。

如果第二个操作数的指数大于第一个操作数的指数，则可能需要进行舍入。在这种情况下，舍入模式由给定的rounding参数决定，否则由给定的 context参数决定；如果两个参数都没有给出，则使用当前线程上下文的舍入模式。

只要结果指数大于 Emax或小于 ，就会返回错误Etiny。

radix( ) 

Return ， 类在其中执行所有算术运算Decimal(10)的基数（基数） 。Decimal包括在内是为了与规范兼容。

remainder_near(other, context=None)

将 self 除以 other 返回余数。 这与 self % other 的不同之处在于，选择余数的符号是为了最小化其绝对值。 更准确地说，返回值是 self – n * other，其中 n 是最接近 self / other 精确值的整数，如果两个整数同样接近，则选择偶数。

如果结果为零，则其符号将是自我的符号。

>>> Decimal(18).remainder_near(Decimal(10))
Decimal('-2')
>>> Decimal(25).remainder_near(Decimal(10))
Decimal('5')
>>> Decimal(35).remainder_near(Decimal(10))
Decimal('-5')

clear_flags( ) 

将所有标志重置为0。

clear_traps( ) 

将所有陷阱重置为0。

3.3 版中的新功能。

copy( ) 

返回上下文的副本。

copy_decimal() ¶

返回 Decimal 实例 num 的副本。

create_decimal() ¶

从num创建一个新的 Decimal 实例，但使用self作为上下文。与Decimal构造函数不同，上下文精度、舍入方法、标志和陷阱应用于转换。

这很有用，因为常量的精度通常高于应用程序所需的精度。另一个好处是舍入会立即消除超出当前精度的数字的意外影响。在以下示例中，使用未舍入的输入意味着将零加到总和中可以改变结果：

>>> getcontext().prec = 3
>>> Decimal('3.4445') + Decimal('1.0023')
Decimal('4.45')
>>> Decimal('3.4445') + Decimal(0) + Decimal('1.0023')
Decimal('4.44')

该方法实现了IBM规范的to-number操作。如果参数是字符串，则不允许有前导或尾随空格或下划线。

create_decimal_from_float(f)

从 float f创建一个新的 Decimal 实例，但使用self 作为上下文进行舍入。与Decimal.from_float()类方法不同，上下文精度、舍入方法、标志和陷阱应用于转换。

>>> context = Context(prec=5, rounding=ROUND_DOWN)
>>> context.create_decimal_from_float(math.pi)
Decimal('3.1415')
>>> context = Context(prec=5, traps=[Inexact])
>>> context.create_decimal_from_float(math.pi)
Traceback (most recent call last):
    ...
decimal.Inexact: None