二进制浮点数的问题

在十进制数学中，许多数字无法用固定数量的十进制数字表示，例如 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… 您可以看到，问题在于某些十进制数字无法精确地表示为二进制，从而导致小的舍入误差。

因此，我们需要一个十进制数据类型来精确地表示十进制数字。我们需要十进制数据类型，而不是二进制数据类型。

为什么是浮点数？

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

浮点数使用固定数量的数字（精度）来表示一个数字，当数字变得太大或太小时使用指数。例如，精度为 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 就没有意义——这是表示金额的正确方法，在现实世界中，这是一个真正主要的用例。

无论如何，如果您对这种数据类型感兴趣，您可能希望查看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 的拟议修订版 [5] [6]。

该模型有三个组成部分

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

数字

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

有限数字由三个参数定义

• 符号：0（正）或 1（负）。
• 系数：非负整数。
• 指数：带符号整数，系数乘数的 10 的幂。

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

(-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”。请参阅下面的舍入算法。

• 标志和陷阱使能器：异常情况被分组为信号，可以单独控制，每个信号都包含一个标志（布尔值，当信号发生时设置）和一个陷阱使能器（控制行为的布尔值）。信号包括：“钳位”、“除以零”、“不精确”、“无效操作”、“溢出”、“舍入”、“次正规”和“下溢”。

默认上下文

规范定义了两种默认上下文，用户应该能够轻松地选择它们。

基本默认上下文

• 标志：全部设置为 0
• 陷阱使能器：不精确、舍入和次正规设置为 0；其他全部设置为 1
• 精度：设置为 9
• 舍入：设置为四舍五入

扩展默认上下文

• 标志：全部设置为 0
• 陷阱使能器：全部设置为 0
• 精度：设置为 9
• 舍入：设置为四舍六入

异常情况

下表列出了算术运算期间可能出现的异常情况、相应的信号和定义的结果。有关详细信息，请参阅规范 [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：丢弃的数字被忽略；结果不变（向 0 舍入，截断）

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（远离 0 舍入）

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 为假，否则为真）

在 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_sci_string(d)
• 转换为工程计数法字符串：to_eng_string(d)
• 转换为数字：create_decimal(number)，有关number，请参见显式构造。
• 绝对值：abs(d)
• 加法：add(d, n)
• 减法：subtract(d, n)
• 比较：compare(d, n)
• 除法：divide(d, n)
• 整数除法：divide_int(d, n)
• 最大值：max(d, n)
• 最小值：min(d, n)
• 负数：minus(d)
• 正数：plus(d)
• 乘法：multiply(d, n)
• 规范化：normalize(d)
• 量化：quantize(d, d)
• 求余：remainder(d)
• 最近余数：remainder_near(d)
• 四舍五入到整数：to_integral(d)
• 相同量子：same_quantum(d, d)
• 平方根：sqrt(d)
• 幂运算：power(d, n)

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

这些方法从 Context 返回有用的信息

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

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

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

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

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