6.2. decimal — 高精度计算模块 | 数学模块 |《python 3 标准库实例教程》| python 技术论坛-380玩彩网官网入口
目的：使用定点数和浮点数进行十进制计算
高精度计算模块 decimal 采用了大多数人熟悉的浮点和定点数实现，而不是程序员们熟悉的，同时也是大多数计算机硬件支持的ieee版本的浮点数实现。 一个 decimal 对象能够精确地表示任何数字，以及能够无条件进位或无条件舍去到任意的精度。
十进制值
decimal 类的实例表示为十进制的值。构造函数采用一个整数或字符串作为参数。在创建 decimal对象之前，可以将浮点数转换为字符串，从而让调用者显式地处理不能用硬件浮点数表示的数位。或者，使用类方法 from_float() 精确地转换为十进制表示形式。
decimal_create.py
import decimal
fmt = '{0:<25} {1:<25}'
print(fmt.format('input', 'output'))
print(fmt.format('-' * 25, '-' * 25))
# 整数
print(fmt.format(5, decimal.decimal(5)))
# 字符串
print(fmt.format('3.14', decimal.decimal('3.14')))
# 浮点数
f = 0.1
print(fmt.format(repr(f), decimal.decimal(str(f))))
print('{:<0.23g} {:<25}'.format(
f,
str(decimal.decimal.from_float(f))[:25])
)
浮点数 0.1 的值在二进制中并不是一个精确值，所以 float 类型和 decimal 类型的值不同。在该输出的最后一行中，完整的字符串表示被截断为25个字符。
$ python3 decimal_create.py
input output
------------------------- -------------------------
5 5
3.14 3.14
0.1 0.1
0.10000000000000000555112 0.10000000000000000555111
decimals 同样能从一个元组创建，其包含符号位 「0 为正， 1 为负」 , 一个 tuple 类型的数位元组，和一个表示指数的整数。
decimal_tuple.py
import decimal
# 元组
t = (1, (1, 1), -2)
print('input :', t)
print('decimal:', decimal.decimal(t))
基于元组的表示方式不便于创建，但确实提供了一种在不损失精度的前提下便捷地导出十进制值的方式。元组表单能够通过网络传输或者存储在不支持精确十进制值的数据库中，之后再转换回 decimal 实例。$ python3 decimal_tuple.py
input : (1, (1, 1), -2)
decimal: -0.11
格式化
decimal 使用和其它数值类型一样的语法和选项来响应 python 的 。
decimal_format.py
import decimal
d = decimal.decimal(1.1)
print('precision:')
print('{:.1}'.format(d))
print('{:.2}'.format(d))
print('{:.3}'.format(d))
print('{:.18}'.format(d))
print('\nwidth and precision combined:')
print('{:5.1f} {:5.1g}'.format(d, d))
print('{:5.2f} {:5.2g}'.format(d, d))
print('{:5.2f} {:5.2g}'.format(d, d))
print('\nzero padding:')
print('{:05.1}'.format(d))
print('{:05.2}'.format(d))
print('{:05.3}'.format(d))
格式字符串可以控制输出的宽度，精度（有效位数）以及如何填充值以填充宽度。
$ python3 decimal_format.py
precision:
1
1.1
1.10
1.10000000000000009
width and precision combined:
1.1 1
1.10 1.1
1.10 1.1
zero padding:
00001
001.1
01.10
算术
decimal 重载了简单的算术运算符，因此实例的操作方式与内置数值类型的操作方式大致相同。
decimal_operators.py
import decimal
a = decimal.decimal('5.1')
b = decimal.decimal('3.14')
c = 4
d = 3.14
print('a =', repr(a))
print('b =', repr(b))
print('c =', repr(c))
print('d =', repr(d))
print()
print('a b =', a b)
print('a - b =', a - b)
print('a * b =', a * b)
print('a / b =', a / b)
print()
print('a c =', a c)
print('a - c =', a - c)
print('a * c =', a * c)
print('a / c =', a / c)
print()
print('a d =', end=' ')
try:
print(a d)
except typeerror as e:
print(e)
decimal 运算符也接受整数参数，但浮点值必须转换为 decimal 实例。
$ python3 decimal_operators.py
a = decimal('5.1')
b = decimal('3.14')
c = 4
d = 3.14
a b = 8.24
a - b = 1.96
a * b = 16.014
a / b = 1.624203821656050955414012739
a c = 9.1
a - c = 1.1
a * c = 20.4
a / c = 1.275
a d = unsupported operand type(s) for : 'decimal.decimal' and
'float'
除了基本算术之外，decimal包括查找基数10和自然对数的方法。 log10() 和 ln() 的返回值是 decimal 实例，因此可以直接在带有其他值的公式中使用它们。
特殊值
除了预期的数值，“十进制”可以表示几个特殊值，包括无穷大的正值和负值，“不是数字”和零。
decimal_special.py
import decimal
for value in ['infinity', 'nan', '0']:
print(decimal.decimal(value), decimal.decimal('-' value))
print()
# 数学的无穷
print('infinity 1:', (decimal.decimal('infinity') 1))
print('-infinity 1:', (decimal.decimal('-infinity') 1))
# 打印比较 nan
print(decimal.decimal('nan') == decimal.decimal('infinity'))
print(decimal.decimal('nan') != decimal.decimal(1))
添加到无限值会返回另一个无限值。比较 nan 的相等性总是返回 false，比较不等总是返回 true。与 nan 排序次序的比较是未定义的，会导致错误。
$ python3 decimal_special.py
infinity -infinity
nan -nan
0 -0
infinity 1: infinity
-infinity 1: -infinity
false
true
上下文
到目前为止，所有示例都使用了 decimal 模块的默认行为。可以通过使用 context 覆盖这些设置，例如保留的精度，如何执行舍入，错误处理等。上下文可以应用于线程中的所有 decimal 实例，也可以应用于小代码区域中的本地。
当前上下文
要检索当前的全局上下文，请使用 getcontext。
decimal_getcontext.py
import decimal
context = decimal.getcontext()
print('emax =', context.emax)
print('emin =', context.emin)
print('capitals =', context.capitals)
print('prec =', context.prec)
print('rounding =', context.rounding)
print('flags =')
for f, v in context.flags.items():
print(' {}: {}'.format(f, v))
print('traps =')
for t, v in context.traps.items():
print(' {}: {}'.format(t, v))
此示例脚本显示 context 的公共属性。
$ python3 decimal_getcontext.py
emax = 999999
emin = -999999
capitals = 1
prec = 28
rounding = round_half_even
flags =
: false
: false
: false
: false
: false
: false
: false
: false
: false
traps =
: true
: false
: true
: true
: false
: false
: false
: false
: false
精确度
上下文的 prec 属性控制为算术结果创建的新值保持的精度值。如所描述的那样保持字面量。
decimal_precision.py
import decimal
d = decimal.decimal('0.123456')
for i in range(1, 5):
decimal.getcontext().prec = i
print(i, ':', d, d * 1)
要更改精度，请将 1 和 decimal.max_prec 之间的新值直接指定给属性。
$ python3 decimal_precision.py
1 : 0.123456 0.1
2 : 0.123456 0.12
3 : 0.123456 0.123
4 : 0.123456 0.1235
四舍五入
有几种舍入选项可以使值保持在所需的精度范围内。
round_ceiling
始终向正无穷舍入。
round_down
始终向零舍入。
round_floor
始终向负无穷舍入。
round_half_down
如果最后一个有效数字大于或等于 5，则从零开始，否则为零。
round_half_even
与 round_half_down 类似，但如果值为 5 则检查前一个数字。偶数值会导致结果向下舍入，奇数位会导致结果向上舍入。
round_half_up
与 round_half_down 类似，除非最后一位有效数字是 5，否则该值将从零开始舍入。
round_up
往零的反方向舍入。
round_05up
如果最后一位是 0 或 5，则舍入为零，否则为零。
decimal_rounding.py
import decimal
context = decimal.getcontext()
rounding_modes = [
'round_ceiling',
'round_down',
'round_floor',
'round_half_down',
'round_half_even',
'round_half_up',
'round_up',
'round_05up',
]
header_fmt = '{:10} ' ' '.join(['{:^8}'] * 6)
print(header_fmt.format(
' ',
'1/8 (1)', '-1/8 (1)',
'1/8 (2)', '-1/8 (2)',
'1/8 (3)', '-1/8 (3)',
))
for rounding_mode in rounding_modes:
print('{0:10}'.format(rounding_mode.partition('_')[-1]),
end=' ')
for precision in [1, 2, 3]:
context.prec = precision
context.rounding = getattr(decimal, rounding_mode)
value = decimal.decimal(1) / decimal.decimal(8)
print('{0:^8}'.format(value), end=' ')
value = decimal.decimal(-1) / decimal.decimal(8)
print('{0:^8}'.format(value), end=' ')
print()
此程序显示使用不同算法将相同值四舍五入到不同精度级别的效果。
$ python3 decimal_rounding.py
1/8 (1) -1/8 (1) 1/8 (2) -1/8 (2) 1/8 (3) -1/8 (3)
ceiling 0.2 -0.1 0.13 -0.12 0.125 -0.125
down 0.1 -0.1 0.12 -0.12 0.125 -0.125
floor 0.1 -0.2 0.12 -0.13 0.125 -0.125
half_down 0.1 -0.1 0.12 -0.12 0.125 -0.125
half_even 0.1 -0.1 0.12 -0.12 0.125 -0.125
half_up 0.1 -0.1 0.13 -0.13 0.125 -0.125
up 0.2 -0.2 0.13 -0.13 0.125 -0.125
05up 0.1 -0.1 0.12 -0.12 0.125 -0.125
局部上下文
可以使用 with 语句将上下文应用于代码块。
decimal_context_manager.py
import decimal
with decimal.localcontext() as c:
c.prec = 2
print('local precision:', c.prec)
print('3.14 / 3 =', (decimal.decimal('3.14') / 3))
print()
print('default precision:', decimal.getcontext().prec)
print('3.14 / 3 =', (decimal.decimal('3.14') / 3))
context 支持 with 使用的上下文管理器 api，因此设置仅适用于代码块。
$ python3 decimal_context_manager.py
local precision: 2
3.14 / 3 = 1.0
default precision: 28
3.14 / 3 = 1.046666666666666666666666667
每个实例上下文
上下文也可用于构造 decimal 实例，然后继承从上下文转换的精度和舍入参数。
decimal_instance_context.py
import decimal
# 设置精度有限的上下文
c = decimal.getcontext().copy()
c.prec = 3
# 创建我们的常数
pi = c.create_decimal('3.1415')
# 常数值四舍五入
print('pi :', pi)
# 使用全局上下文常量的结果
print('result:', decimal.decimal('2.01') * pi)
例如，这使应用程序可以与用户数据的精度分开地选择常量值的精度。
$ python3 decimal_instance_context.py
pi : 3.14
result: 6.3114
线程
“全局”上下文实际上本地是线程，因此可以使用不同的值来配置每个线程。
decimal_thread_context.py
import decimal
import threading
from queue import priorityqueue
class multiplier(threading.thread):
def __init__(self, a, b, prec, q):
self.a = a
self.b = b
self.prec = prec
self.q = q
threading.thread.__init__(self)
def run(self):
c = decimal.getcontext().copy()
c.prec = self.prec
decimal.setcontext(c)
self.q.put((self.prec, a * b))
a = decimal.decimal('3.14')
b = decimal.decimal('1.234')
# priorityqueue 将返回按精度排序的值，
# 无论线程完成时是什么顺序。
q = priorityqueue()
threads = [multiplier(a, b, i, q) for i in range(1, 6)]
for t in threads:
t.start()
for t in threads:
t.join()
for i in range(5):
prec, value = q.get()
print('{} {}'.format(prec, value))
此示例使用指定的内容创建新上下文，然后在每个线程中安装它。
$ python3 decimal_thread_context.py
1 4
2 3.9
3 3.87
4 3.875
5 3.8748
也可以看看
- -- 关于浮点表示和算术的文章。
- -- python 教程中的文章描述了浮点在数学中的表示问题。
本译文仅用于学习和交流目的，转载请务必注明文章译者、出处、和本文链接
我们的翻译工作遵照 cc 协议，如果我们的工作有侵犯到您的权益，请及时联系380玩彩网官网入口。
