Python之decimal模块的使⽤decimal模块的作⽤
Decimal模块的实例可以准确地表⽰任何数，对其上或其下取整，还可以限制有效数字个数。
1、Decimal创建的使⽤
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} {1:<25}'.format(
f,
# 把浮点数转换成⼗进制数
str(decimal.Decimal.from_float(f))[:25]))
decimal_create.py
测试效果
Input Output
------------------------- -------------------------
5 5
3.14 3.14
0.1 0.1
0.1 0.10000000000000000555111
2、⽤元组的形式创建⼩数
import decimal
# 元组解析
# 元组参数⼀: 0，表⽰正数，1，表⽰负数
# 元组参数⼆：⼗进制整数，例如下⾯是198
# 元组参数三:⼩数点⼏位
t = (1, (1, 9, 8), -2)
print('Input :', t)
六笔画print('Decimal :', decimal.Decimal(t))
decimal_tuple.py
测试结果
Input : (1, (1, 9, 8, 8), -2)
Decimal : -19.88
3、⼩数的格式化
import decimal
d = decimal.Decimal(1.1)
# %f ——保留⼩数点后⾯六位有效数字 %.3f，保留3位⼩数位
# %e ——保留⼩数点后⾯六位有效数字，指数形式输出 %.3e，保留3位⼩数位，使⽤科学计数法
# %g ——在保证六位有效数字的前提下，使⽤⼩数⽅式，否则使⽤科学计数法 %.3g，保留3位有效数字，使⽤⼩数或科学计数法print('精确度:')
print('{:.1}'.format(d))
print('{:.2}'.format(d))
print('{:.3}'.format(d))
print('{:.18}'.format(d))
print('\n宽度和精度相结合')
print('{:5.1f} {:5.1g}'.format(d, d))
print('{:5.2f} {:5.2g}'.format(d, d))
print('\n0填充')
# 格式05：表⽰共5位，⽤0填充，.1表⽰⼩数据在左边第⼀位print('{:05.1}'.format(d))
print('{:05.2}'.format(d))
print('{:05.3}'.format(d))
decimal_format.py
测试结果
精确度:
1
1.1
1.10
1.10000000000000009
宽度和精度相结合
1.1 1
1.10 1.1
0填充
00001
001.1
01.10
4、Decimal算术运算
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()
# Decimal()对象的加减乘除
print('a + b =', a + b)
print('a - b =', a - b)
print('a * b =', a * b)
print('a / b =', a / b)
print()
# Decimal()对象与int进⾏的加减乘除
print('a + c =', a + c)
print('a - c =', a - c)
print('a * c =', a * c)
print('a / c =', a / c)
print()
# Decimal()对象不⽀持与float进⾏的加减乘除
print('a + d =', end='')
try:
print(a + d)
except TypeError as e:
print(e)
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'
5、Decimal数学的特殊值
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))
decimal_special.py
测试结果
Infinity -Infinity
NaN -NaN
0 -0
Infinity + 1: Infinity
-Infinity + 1: -Infinity
Fal
True
6、decimal上下⽂属性的获取
import decimal
context = text()
print('Emax =', context.Emax)
print('Emin =', context.Emin)
print('capitals =', context.capitals)
print('prec =', context.prec)
print('rounding =', unding)
print('flags =')
for f, v in context.flags.items():
print(' {}: {}'.format(f, v))
print('traps =')
for t, v aps.items():
print(' {}: {}'.format(t, v))
香肠制作方法decimal_getcontext.py
测试结果
Emax = 999999
Emin = -999999
capitals = 1
prec = 28
rounding = ROUND_HALF_EVEN
flags =
<class'decimal.InvalidOperation'>: Fal
<class'decimal.FloatOperation'>: Fal
<class'decimal.DivisionByZero'>: Fal
<class'decimal.Overflow'>: Fal
<class'decimal.Underflow'>: Fal
<class'decimal.Subnormal'>: Fal
<class'decimal.Inexact'>: Fal
<class'decimal.Rounded'>: Fal
<class'decimal.Clamped'>: Fal
traps =
<class'decimal.InvalidOperation'>: True
<class'decimal.FloatOperation'>: Fal
<class'decimal.DivisionByZero'>: True
<class'decimal.Overflow'>: True
<class'decimal.Underflow'>: Fal
<class'decimal.Subnormal'>: Fal
<class'decimal.Inexact'>: Fal
<class'decimal.Rounded'>: Fal
<class'decimal.Clamped'>: Fal
7、⽤Decimal的上⽂属性prec，来控制精度
import decimal
d = decimal.Decimal('0.123456')
for i in range(1, 5):
什么蔬菜补肾text().prec = i
print(i, ':', d, d * 1)
decimal_precision.py
测试结果
1 : 0.123456 0.1
2 : 0.123456 0.12
3 : 0.123456 0.123
4 : 0.123456 0.1235
8、取整的⽰例
ROUND_CEILING : 总是趋向⽆穷⼤向上取整。
ROUND_DOWN : 总是趋向0取整。
ROUND_FLOOR : 总是趋向⽆穷⼤向下取整。
ROUND_HALF_DOWN : 如果最后⼀个有效数字⼤于或等于5则朝0反⽅向取整；否则，趋向0取整。
ROUND_HALF_EVEN : 类似于ROUND_HALF_DOWN，不过如果最后⼀个有效数字为5，则值检查前⼀位。偶数值会导致结果向下取整，奇数值导致结果向上取整。ROUND_HALF_UP ：类似于ROUND_HALF_DOWN，不过如果最后⼀个有效数字为5，则值会朝0的反⽅向取整。
ROUND_UP : 朝0的反⽅向取整
ROUND_05UP ：如果最后⼀位是０或５，则朝０的反⽅向取整；否则向0取整。
import decimal
context = text()
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
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()
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
9、本地上下⽂
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:', text().prec)
print('3.14 / 3 =', (decimal.Decimal('3.14') / 3))
decimal_context_manager.py
测试效果
Local precision: 2怎么开启系统还原
3.14 / 3 = 1.0
Default precision: 28
3.14 / 3 = 1.046666666666666666666666667
10、多实例控制精度
decimal_instance_context.py
测试效果
PI : 3.14
RESULT: 6.3114
11、decimal上下⽂全局线程的⽰例（即每个线程配置不⼀样的精度，实现不同线程区分精度）
import decimal
import threading
from queue import PriorityQueue
class Multiplier(threading.Thread):
def__init__(lf, a, b, prec, q):
lf.a = a
lf.b = b
lf.prec = prec
lf.q = q
threading.Thread.__init__(lf)
def run(lf):
c = text().copy()
c.prec = lf.prec
lf.q.put((lf.prec, lf.a * lf.b))
a = decimal.Decimal('3.14')
b = decimal.Decimal('1.234')
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))磁带的英文
decimal_thread_context.py
测试效果
1 4
2 3.9
3 3.87
两个心愿4 3.875
5 3.8748
12、decimal模块log函数的使⽤⽰例
