二进制浮点数的困境

在十进制数学中，许多数字无法用固定小数位数的十进制数表示，例如 1/3 = 0.3333333333……。

在基数 2（标准浮点数计算方式）中，1/2 = 0.1，1/4 = 0.01，1/8 = 0.001 等。十进制的 0.2 等于 2/10 等于 1/5，导致二进制小数数为 0.001100110011001……。正如您所见，问题在于某些十进制数无法在二进制中精确表示，从而导致微小的舍入误差。

因此，我们需要一个能够精确表示十进制数的 Decimal 数据类型。我们需要的不是二进制数据类型，而是十进制数据类型。

为什么需要浮点数？

所以我们转向十进制，但为什么是浮点数？

浮点数使用固定数量的数字（精度）来表示数字，当数字过大或过小时则使用指数。例如，精度为 5

  1234 ==>   1234e0
 12345 ==>  12345e0
123456 ==>  12346e1

（请注意，最后一行数字已舍入以适应五个数字）。

相比之下，我们有一个具有无限精度的 long 整数的例子，这意味着您可以拥有任意大的数字，而不会丢失任何信息。

在定点数中，小数点的位置是固定的。有关定点数据类型，请参阅 Tim Peter 的 SourceForge 上的 FixedPoint [4]。我选择浮点数是因为它更容易实现标准的算术行为，然后您可以在 Decimal 之上实现定点数据类型。

但是，为什么我们不能拥有无限精度的浮点数？这并不容易，因为存在不精确的除法。例如：1/3 = 0.3333333333333… 无限循环。在这种情况下，您应该存储无限个 3，这会占用太多内存；）。

John Roth 提议取消除法运算符，强制用户使用显式方法，以避免这种麻烦。这在 comp.lang.python 中引起了负面反应，因为每个人都希望在数字数据类型中支持 / 运算符。

暴露了这一点后，您可能在想“嘿！我们不能直接存储 1 和 3 作为分子和分母吗？”，这让我们进入下一个话题。

为什么不使用有理数？

有理数使用两个整数（分子和分母）存储。这意味着算术运算无法直接执行（例如，要将两个有理数相加，您首先需要计算公分母）。

引用 Alex Martelli

将两个有理数（分别占用 O(M) 和 O(N) 空间）相加得到一个占用 O(M+N) 内存空间的有理数，其性能影响实在太麻烦了。在纯 Python 和扩展（例如 gmpy）中都有优秀的 Rational 实现，但我认为它们将始终是“小众市场”。可能值得 PEP，但没有 Decimal 就不值得——Decimal 才是表示货币总额的正确方式，这是现实世界中一个真正主要的用例。

无论如何，如果您对这种数据类型感兴趣，您可能想看看 PEP 239：为 Python 添加有理数类型。

那么，我们拥有什么？

结果是 Decimal 数据类型，具有有限精度和浮点特性。

它会有用吗？我无法比 Alex Martelli 说得更好

Python（开箱即用）不允许您拥有具有您指定的任何精度的二进制浮点数：您仅限于硬件提供的精度。Decimal，无论用作定点数还是浮点数，都不应受到此类限制：您在创建数字时指定的任何有限精度（只要您的内存允许）都应该同样有效。编程简单性的绝大部分开销都可以隐藏在应用程序程序之外，并置于合适的十进制算术类型中。根据 http://speleotrove.com/decimal/，一种数据类型可以用于整数、定点和浮点十进制算术——以及用于不会让应用程序程序员抓狂的货币算术。

这种数据类型有几种用途。如前所述，我将将其用作 Money 的基础。在这种情况下，有限精度不是问题；引用 Tim Peters

20 位精度足以支付自古以来全球经济总产值，精确到分。

算术模型

该规范基于十进制算术模型，由相关标准定义：IEEE 854 [3]、ANSI X3-274 [1] 和 IEEE 754 [6] 的拟议修订版 [5]。

模型包含三个组件

• 数字：操作使用的输入或输出的数值。
• 操作：加法、乘法等。
• 上下文：一组用户可以选择的参数和规则，用于控制操作的结果（例如，使用的精度）。

数字

数字可以是有限的或特殊值。前者可以精确表示。后者是无穷大和未定义（如 0/0）。

有限数字由三个参数定义

• 符号：0（正）或 1（负）。
• 系数：一个非负整数。
• 指数：一个带符号整数，表示系数的十的幂。

有限数字的数值由下式给出

(-1)**sign * coefficient * 10**exponent

特殊值命名如下

• 无穷大：一个无限大的值。可以是正无穷大或负无穷大。
• 安静 NaN（“qNaN”）：表示未定义的结果（非数字）。不引起无效操作条件。NaN 的符号无意义。
• 信令 NaN（“sNaN”）：也是非数字，但在任何操作中使用时都会引起无效操作条件。

背景

上下文是一组用户可以选择的参数和规则，用于控制操作的结果（例如，使用的精度）。

上下文之所以得名，是因为它包围着 Decimal 数字，上下文的某些部分充当操作的输入和输出。由应用程序决定使用一个或多个上下文，但绝不是每个 Decimal 数字都有一个上下文。例如，典型的用法是在程序开始时将上下文的精度设置为 20 位，然后不再显式使用上下文。

这些定义不影响 Decimal 数字的内部存储，只影响算术运算的执行方式。

上下文主要由以下参数定义（请参阅 上下文属性 以了解所有上下文属性）

• 精度：算术运算（整数 > 0）可能产生结果的最大有效数字位数。此值没有最大值。
• 舍入：必要时进行舍入时使用的算法名称，包括“round-down”、“round-half-up”、“round-half-even”、“round-ceiling”、“round-floor”、“round-half-down”和“round-up”。请参阅下面的 舍入算法。
• 标志和陷阱启用器：异常情况分为信号，可单独控制，每个信号包含一个标志（发生信号时设置为布尔值）和一个陷阱启用器（控制行为的布尔值）。信号包括：“clamped”、“division-by-zero”、“inexact”、“invalid-operation”、“overflow”、“rounded”、“subnormal”和“underflow”。

默认上下文

该规范定义了两个默认上下文，用户应易于选择。

基本默认上下文

• flags：全部设置为 0
• trap-enablers：inexact、rounded 和 subnormal 设置为 0；所有其他设置为 1
• precision：设置为 9
• rounding：设置为 round-half-up

扩展默认上下文

• flags：全部设置为 0
• trap-enablers：全部设置为 0
• precision：设置为 9
• rounding：设置为 round-half-even

异常情况

下表列出了算术运算期间可能出现的异常情况、相应的信号和定义的结果。有关详细信息，请参阅规范 [2]。

注意：当标准谈论“存储不足”时，只要这是关于没有足够存储空间来保存数字内部结构而与实现相关的行为，此实现将引发 MemoryError。

关于溢出和下溢，python-dev 上曾就人工限制进行了长期讨论。普遍的共识是，除非有重要原因，否则应仅保留人工限制。Tim Peters 提出了三个理由

…消除指数的界限实际上意味着溢出（和下溢）永远不会发生。但在现实世界的浮点数使用中，溢出是一种有价值的安全网，就像煤矿里的金丝雀一样，当程序出现故障时能及早发出危险信号。

几乎所有 854 的实现都使用（正如 IBM 的标准所建议的）“禁止”指数值来编码非有限数字（无穷大和 NaN）。有界指数几乎可以以零额外存储成本来做到这一点。如果指数无界，则必须改用额外的位数。这种成本在尝试更节省时间和空间更高效的实现之前是隐藏的。

IBM 标准虽然庞大，但只是提供完整数字功能的一个微小开端。指数大小无界将极大地复杂化实现，例如，十进制 sin() 和 cos()（那时对 pi 的有效数字需要知道多少才能执行参数约简，没有先验限制）。

Edward Loper 给出了一个例子，说明何时应越过界限：概率。

话虽如此，Robert Brewer 和 Andrew Lentvorski 希望用户可以轻松修改这些限制。实际上，这完全有可能

>>> d1 = Decimal("1e999999999")     # at the exponent limit
>>> d1
Decimal("1E+999999999")
>>> d1 * 10                         # exceed the limit, got infinity
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in ?
    d1 * 10
  ...
  ...
Overflow: above Emax
>>> getcontext().Emax = 1000000000  # increase the limit
>>> d1 * 10                         # does not exceed any more
Decimal("1.0E+1000000000")
>>> d1 * 100                        # exceed again
Traceback (most recent call last):
  File "<pyshell#3>", line 1, in ?
    d1 * 100
  ...
  ...
Overflow: above Emax

舍入算法

round-down：忽略被丢弃的数字；结果不变（向零舍入，截断）

1.123 --> 1.12
1.128 --> 1.12
1.125 --> 1.12
1.135 --> 1.13

round-half-up：如果被丢弃的数字表示大于或等于一半（0.5），则结果应加 1；否则忽略被丢弃的数字

1.123 --> 1.12
1.128 --> 1.13
1.125 --> 1.13
1.135 --> 1.14

round-half-even：如果被丢弃的数字表示大于一半（0.5），则结果系数加 1；如果它们表示小于一半，则结果不变；否则，如果结果的最右一位是偶数，则结果不变，如果其最右一位是奇数，则结果加 1（使其成为偶数）。

1.123 --> 1.12
1.128 --> 1.13
1.125 --> 1.12
1.135 --> 1.14

round-ceiling：如果所有被丢弃的数字都是零或符号为负，则结果不变；否则，结果加 1（向上舍入到正无穷大）

 1.123 -->  1.13
 1.128 -->  1.13
-1.123 --> -1.12
-1.128 --> -1.12

round-floor：如果所有被丢弃的数字都是零或符号为正，则结果不变；否则，结果的绝对值加 1（向下舍入到负无穷大）

 1.123 -->  1.12
 1.128 -->  1.12
-1.123 --> -1.13
-1.128 --> -1.13

round-half-down：如果被丢弃的数字表示大于一半（0.5），则结果加 1；否则忽略被丢弃的数字

1.123 --> 1.12
1.128 --> 1.13
1.125 --> 1.12
1.135 --> 1.13

round-up：如果所有被丢弃的数字都是零，则结果不变，否则结果加 1（远离零舍入）

1.123 --> 1.13
1.128 --> 1.13
1.125 --> 1.13
1.135 --> 1.14

显式构造

显式构造不受上下文影响（没有舍入，没有精度限制等），因为上下文仅影响操作结果。唯一的例外是当您从上下文创建时。

Decimal(35)
Decimal(-124)

Decimal("-12")
Decimal("23.2e-7")

Decimal("Inf")
Decimal("NaN")

(1) says  D(1.1) == D('1.1')
but       1.1 == 1.1000000000000001
so        D(1.1) == D(1.1000000000000001)
together: D(1.1000000000000001) == D('1.1')

d = Decimal (1.1, 1)  # take float value to 1 decimal place
d = Decimal (1.1)  # gets `places` from pre-set context

Decimal.from_float(floatNumber, [decimal_places])

Decimal.from_float(1.1, 2): The same as doing Decimal('1.1').
Decimal.from_float(1.1, 16): The same as doing Decimal('1.1000000000000001').
Decimal.from_float(1.1): The same as doing Decimal('1100000000000000088817841970012523233890533447265625e-51').

Decimal((1, (3, 2, 2, 5), -2))     # for -32.25

Decimal( (0, (0,), 'F') )          # for Infinity
Decimal( (0, (0,), 'n') )          # for Not a Number

Decimal(value1)
Decimal.from_float(value2, [decimal_places])

D.using_context(number, context)

context.create_decimal(number)

# n is any datatype accepted in Decimal(n) plus float
mycontext.create_decimal(n)

>>> # create a standard decimal instance
>>> Decimal("11.2233445566778899")
Decimal("11.2233445566778899")
>>>
>>> # create a decimal instance using the thread context
>>> thread_context = getcontext()
>>> thread_context.prec
28
>>> thread_context.create_decimal("11.2233445566778899")
Decimal("11.2233445566778899")
>>>
>>> # create a decimal instance using other context
>>> other_context = thread_context.copy()
>>> other_context.prec = 4
>>> other_context.create_decimal("11.2233445566778899")
Decimal("11.22")

隐式构造

由于隐式构造是操作的结果，因此它将受到上下文的影响，具体细节将在各点详述。

John Roth 建议“其他类型应以 Decimal() 构造函数处理它的方式进行处理”。但 Alex Martelli 认为

这种与 Python 传统的彻底决裂将是一个可怕的错误。23+“43”不像 23+int(“45”) 那样处理，而且这非常好。用户明确表示他们想要构造（转换）与仅仅错误地将一个可能为字符串的对象相加，这是完全不同的事情。

因此，在此我再次定义每种数据类型的行为。

上下文的使用

在上一份预 PEP 中，我说过“上下文必须无处不在，意味着对其的更改会影响当前和未来的所有 Decimal 实例”。我错了。作为回应，John Roth 说

上下文应该可以为特定用法选择。也就是说，应用程序应该能够同时处理多个不同的上下文。

在 comp.lang.python 中，Aahz 解释说，这个想法是有一个“每个线程一个上下文”。因此，一个线程的所有实例都属于一个上下文，您可以更改线程 A 中的上下文（以及该线程中实例的行为），而不会更改线程 B 中的任何内容。

另外，再次纠正我，他说

上下文仅适用于操作，不适用于 Decimal 实例；更改上下文不会影响现有实例（如果它们没有操作）。

关于特殊情况，当需要使用与当前上下文不同的规则执行操作时，Tim Peters 说上下文将作为操作的方法。这样，用户“可以创建任何需要的私有上下文对象，并将算术表示为对其私有上下文对象的显式方法调用，从而默认的线程上下文对象既不被查询也不被修改”。

Python 的可用性

• Decimal 应该支持以下情况下的基本算术（+, -, *, /, //, **, %, divmod）和比较（==, !=, <, >, <=, >=, cmp）运算符（请参阅 隐式构造 以了解 OtherType 可以是哪些类型，以及每种情况下的处理方式）
  • Decimal op Decimal
  • Decimal op otherType
  • otherType op Decimal
  • Decimal op= Decimal
  • Decimal op= otherType
• Decimal 应该支持一元运算符（-, +, abs）。
• repr() 应该往返，意味着

  m = Decimal(...)
  m == eval(repr(m))
  

• Decimal 应该是不可变的。
• Decimal 应该支持内置方法
  • min, max
  • float, int, long
  • str, repr
  • hash
  • bool (0 为 false，其他为 true)

python-dev 上曾就 hash() 的行为进行过一些讨论。社区一致认为，如果值相等，那么这些值的哈希值也应该相等。因此，虽然 Decimal(25) == 25 是 True，但 hash(Decimal(25)) 应该等于 hash(25)。

细节是您不能比较 Decimal 和浮点数或字符串，所以我们不必担心它们给出相同的哈希值。简而言之

hash(n) == hash(Decimal(n))   # Only if n is int, long, or Decimal

关于 str() 和 repr() 的行为，Ka-Ping Yee 提议 repr() 的行为与 str() 相同，而 Tim Peters 提议 str() 的行为应像规范中的 to-scientific-string 操作。

这是可能的，因为（来自 Aahz）：“字符串格式已经包含了重建 Decimal 对象所需的所有必要信息。”

并且它也符合规范；Tim Peters

没有要求有一个*命名*为“to_sci_string”的方法，唯一的要求是提供一种*表达* to-sci-string 功能的方式。to-sci-string 的含义由标准精确定义，并且对于 str(Decimal) 和 repr(Decimal) 都是一个不错的选择。

Decimal 属性

Decimal 没有公共属性。内部信息存储在槽中，不应由最终用户访问。

Decimal 方法

以下是规范中定义的转换和算术运算，以及如何通过实际实现来实现这些功能。

• to-scientific-string：使用内置函数 str()

  >>> d = Decimal('123456789012.345')
  >>> str(d)
  '1.23456789E+11'
  

• to-engineering-string：使用方法 to_eng_string()

  >>> d = Decimal('123456789012.345')
  >>> d.to_eng_string()
  '123.456789E+9'
  

• to-number：使用 Context 方法 create_decimal()。标准构造函数或 from_float() 构造函数不能使用，因为它们不使用上下文（正如规范对此转换所指定的）。
• abs：使用内置函数 abs()

  >>> d = Decimal('-15.67')
  >>> abs(d)
  Decimal('15.67')
  

• add：使用运算符 +

  >>> d = Decimal('15.6')
  >>> d + 8
  Decimal('23.6')
  

• subtract：使用运算符 -

  >>> d = Decimal('15.6')
  >>> d - 8
  Decimal('7.6')
  

• compare：使用方法 compare()。此方法（而非内置函数 cmp()）仅应用于处理特殊值。

  >>> d = Decimal('-15.67')
  >>> nan = Decimal('NaN')
  >>> d.compare(23)
  '-1'
  >>> d.compare(nan)
  'NaN'
  >>> cmp(d, 23)
  -1
  >>> cmp(d, nan)
  1
  

• divide：使用运算符 /

  >>> d = Decimal('-15.67')
  >>> d / 2
  Decimal('-7.835')
  

• divide-integer：使用运算符 //

  >>> d = Decimal('-15.67')
  >>> d // 2
  Decimal('-7')
  

• max：使用方法 max()。仅当处理特殊值时才使用此方法（而非内置函数 max()）。

  >>> d = Decimal('15')
  >>> nan = Decimal('NaN')
  >>> d.max(8)
  Decimal('15')
  >>> d.max(nan)
  Decimal('NaN')
  

• min：使用方法 min()。仅当处理特殊值时才使用此方法（而非内置函数 min()）。

  >>> d = Decimal('15')
  >>> nan = Decimal('NaN')
  >>> d.min(8)
  Decimal('8')
  >>> d.min(nan)
  Decimal('NaN')
  

• minus：使用一元运算符 -

  >>> d = Decimal('-15.67')
  >>> -d
  Decimal('15.67')
  

• plus：使用一元运算符 +

  >>> d = Decimal('-15.67')
  >>> +d
  Decimal('-15.67')
  

• multiply：使用运算符 *

  >>> d = Decimal('5.7')
  >>> d * 3
  Decimal('17.1')
  

• normalize：使用方法 normalize()

  >>> d = Decimal('123.45000')
  >>> d.normalize()
  Decimal('123.45')
  >>> d = Decimal('120.00')
  >>> d.normalize()
  Decimal('1.2E+2')
  

• quantize：使用方法 quantize()

  >>> d = Decimal('2.17')
  >>> d.quantize(Decimal('0.001'))
  Decimal('2.170')
  >>> d.quantize(Decimal('0.1'))
  Decimal('2.2')
  

• remainder：使用运算符 %

  >>> d = Decimal('10')
  >>> d % 3
  Decimal('1')
  >>> d % 6
  Decimal('4')
  

• remainder-near：使用方法 remainder_near()

  >>> d = Decimal('10')
  >>> d.remainder_near(3)
  Decimal('1')
  >>> d.remainder_near(6)
  Decimal('-2')
  

• round-to-integral-value：使用方法 to_integral()

  >>> d = Decimal('-123.456')
  >>> d.to_integral()
  Decimal('-123')
  

• same-quantum：使用方法 same_quantum()

  >>> d = Decimal('123.456')
  >>> d.same_quantum(Decimal('0.001'))
  True
  >>> d.same_quantum(Decimal('0.01'))
  False
  

• square-root：使用方法 sqrt()

  >>> d = Decimal('123.456')
  >>> d.sqrt()
  Decimal('11.1110756')
  

• power：用户运算符 **

  >>> d = Decimal('12.56')
  >>> d ** 2
  Decimal('157.7536')
  

以下是其他方法及其存在的原因

• adjusted()：返回调整后的指数。此概念在规范中定义：调整后的指数是当数字表示为科学记数法（小数点前有一个数字）时的指数值。

  >>> d = Decimal('12.56')
  >>> d.adjusted()
  1
  

• from_float()：用于从浮点数数据类型创建实例的类方法。

  >>> d = Decimal.from_float(12.35)
  >>> d
  Decimal('12.3500000')
  

• as_tuple()：显示 Decimal 的内部结构，三元组。此方法不是规范所要求的，但 Tim Peters 提议并获得了社区的同意（它对于开发和调试很有用）。

  >>> d = Decimal('123.4')
  >>> d.as_tuple()
  (0, (1, 2, 3, 4), -1)
  >>> d = Decimal('-2.34e5')
  >>> d.as_tuple()
  (1, (2, 3, 4), 3)
  

上下文属性

这些是可用于修改上下文的属性。

• prec (int)：精度。

  >>> c.prec
  9
  

• rounding (str)：舍入类型（如何舍入）。

  >>> c.rounding
  'half_even'
  

• trap_enablers (dict)：如果 trap_enablers[exception] = 1，则在发生异常时引发异常。

  >>> c.trap_enablers[Underflow]
  0
  >>> c.trap_enablers[Clamped]
  0
  

• flags (dict)：当发生异常时，flags[exception] 会递增（无论 trap_enabler 是否已设置）。应由 Decimal 实例的用户重置。

  >>> c.flags[Underflow]
  0
  >>> c.flags[Clamped]
  0
  

• Emin (int)：最小指数。

  >>> c.Emin
  -999999999
  

• Emax (int)：最大指数。

  >>> c.Emax
  999999999
  

• capitals (int)：布尔标志，用于在字符串中使用“E”（True/1）或“e”（False/0）（例如，“1.32e+2”或“1.32E+2”）。

  >>> c.capitals
  1
  

上下文方法

以下方法符合规范中的 Decimal 功能。请注意，通过特定上下文调用的操作将使用该上下文，而不是线程上下文。

要使用这些方法，请注意当运算符是二元运算符还是单目运算符时，语法会发生变化，例如

>>> mycontext.abs(Decimal('-2'))
'2'
>>> mycontext.multiply(Decimal('2.3'), 5)
'11.5'

因此，以下是规范中的操作和转换以及如何通过上下文实现它们（其中 d 是 Decimal 实例，n 是可以在 隐式构造 中使用的数字）。

• to-scientific-string：to_sci_string(d)
• to-engineering-string：to_eng_string(d)
• to-number：create_decimal(number)，有关 number，请参阅 显式构造。
• abs：abs(d)
• add：add(d, n)
• subtract：subtract(d, n)
• compare：compare(d, n)
• divide：divide(d, n)
• divide-integer：divide_int(d, n)
• max：max(d, n)
• min：min(d, n)
• minus：minus(d)
• plus：plus(d)
• multiply：multiply(d, n)
• normalize：normalize(d)
• quantize：quantize(d, d)
• remainder：remainder(d)
• remainder-near：remainder_near(d)
• round-to-integral-value：to_integral(d)
• same-quantum：same_quantum(d, d)
• square-root：sqrt(d)
• power：power(d, n)

divmod(d, n) 方法通过 Context 支持十进制功能。

这些是返回 Context 中有用信息的类方法。

• Etiny()：考虑精度的最小指数。

  >>> c.Emin
  -999999999
  >>> c.Etiny()
  -1000000007
  

• Etop()：考虑精度的最大指数。

  >>> c.Emax
  999999999
  >>> c.Etop()
  999999991
  

• copy()：返回上下文的副本。