关于python:python的精度控制

1次阅读

共计 3640 个字符，预计需要花费 10 分钟才能阅读完成。

想起来以前有次做客户的收益计算（一群电力客户，给他们调配不同的电量，计算不同调配办法的收益），跟共事一起，共事提供收益计算方法，我负责将计算方法包装起来，做成 web 服务，而后用它来为客户服务（挣客户的钱????）。然鹅，并没有顺利挣到。代码曾经无从讲究，然而起因还记得很轻粗，咱们在控制变量的精度的时候，用的是 python 的 round，打算只保留两位小数（调配给他人的电量单位较大（万千瓦时），所以准确到两位即可，也没有客户违心听你从电量池里边分走几十度电），然鹅精度总是在算着算着的时候，被疏忽掉的后边小数就冒出来了，通过加减乘除，而后进位了！！！！影响了后果的可靠性。

这些冒出来的小数，始终在我印象里就是鬼魅般的存在！！！断人财路，印象粗浅，所以这里好好整顿下 python 的精度问题。

x = 0.0  #important
for i in range(10):
    x+=0.01
    print(x)
  
'''
0.01
0.02
0.03
0.04
0.05
0.060000000000000005
0.07
0.08
0.09
0.09999999999999
'''

因为 Python 中应用双精度浮点数来存储小数。在 Python 应用的 IEEE 754 规范（52M/11E/1S）中，8 字节 64 位存储空间调配了 52 位来存储浮点数的有效数字，11 位存储 指数 ，1 位存储正负号，即这是一种二进制版的迷信计数法格局。尽管 52 位有效数字看起来很多，但麻烦之处在于，二进制小数在示意有理数时极易遇到有限循环的问题。其中很多在十进制小数中是无限的，比方十进制的 1/10，在十进制中能够简略写为 0.1，但在二进制中，他得写成：0.0001100110011001100110011001100110011001100110011001…..（前面全是 1001 循环）。因为浮点数只有 52 位有效数字，从第 53 位开始，就舍入了。这样就造成了题目里提到的”浮点数精度损失“问题。 舍入（round）的规定为“0 舍 1 入”，所以有时候会稍大一点有时候会稍小一点。

所以 round~round~ 几下，精度就失落了！

要了解这个，还须要提及到二进制是怎么保留小数的原理了

好受劝退！

十进制是怎么示意小数的呢？

# 直观 相当于拆分成什么非常位、百分位、千分位来示意
125.456  =  1*10^2+2*10^1+5*10^0+4*10^-1+5*10^-2+6*10^-3
# 指数
1.25456E2 =（1+2*10^-1+5*10^-2+4*10^-3+5*10^-4+6*10^-5）*10^2

同理看一下二进制：

# 二进制  = 十进制    不要在意为什么二进制有个小点
0.1 = 1*2^-1（0.5）0.01 = 1*2^-2（0.25）0.001 = 1*2^-3（0.125）0.0001 = 1*2^-4 (0.0625)
0.00001 = 1*2^-5 (0.03125)

# 其实任意一个数上边这样示意的二进制数据，咱们都能够转换成十进制数，比方
10001.101 = 1*2^4+1*2^0+1*2^-1+1*2^-3
# 上边这个更容易了解为, 看看右边开端的 2^4，是不是很像咱们的十进制提取出 10 的倍数的示意
1.0001101*2^4 =（1+1*2^-4+1*2^-5+1*2^-7 ) * 2^4

能够看到二进制是能够示意很小的数的，也能够是很大的数。那么大大小小的数加起来，就能够示意任意大小的十进制数了。尽管不肯定齐全相等，然而只有我小的数足够多，加起来，近似还是能够的。

所以得出结论：任意一个十进制的数值都能够示意成或者近似示意成（1+12^-n+…12^-m）*2^k

有没有一种拉格朗日表达式的滋味

例如：

8.5 = 1 2^4+1 2^-1

5.4 ~= 4+1+0.25+0.125+0.015625

4+1+0.25+0.125+0.015625 ~= 5.390625

5.390625 = 12^2+12^0+12^-2+12^-3+1*2^-6

这也解释了为什么二进制是不能准确示意 1 /10，因为无论加多少阶，1/10 都不能被上述款式准确示意进去。有些时候也会呈现可能除尽的算式, 计算机中却不能除尽。

为什么说双精度浮点数有 15 位十进制精度，是不是这个起因

经典例子：

#!/bin/python
a = 3240.0
b = 8.0
d = (a*(b/100))/(1+(b/100))
print(d)

'''239.99999999999997'''

float 有 4 个字节 32 为，首位示意符号，接下来 8 位示意阶数 K，剩下 23 示意二进制的小数局部；
double 有 8 个字节，64 位，首位示意符号，11 位示意阶数 k，剩下示意小数局部；（python 默认的小数类型）

1/10 用 2 的指数来示意，的确是示意不完的，没有一个二进制整数倍表达式，所以会有开篇援用的例子里，呈现很多个二进制数。而后回到 round 函数，（0 舍 1 入的规定），是不是感觉到了一丝丝坑意。

在 python 中，一个小数，是能够看到他的二进制示意的，错了，不是二进制，而是 16 进制，不过差不多

a = 1.2
a.hex()
"""0x1.3333333333333p+0"""
b = 0.00000041
b.hex()
"""0x1.b83bf11ce33aap-22"""

# 0x 结尾代表 后边的数据，是一个 16 进制数

# p- 4 示意 * 2^ -4，或者能够简略了解为小数点 左移 4 位,（左移变小, 留神这里还是 16 进制，不是二进制）

小数点前这个“1”是不蕴含于 52 位有效数字之中的，但它的确是一个无效的数字呀，这是因为，在二进制浮点数中，第一位必定是“1”，（是“0”的话就去掉这位，并在指数上 -1）所以就不保留了，这里返回的这个“1”，是为了让人看懂而加上的，在内存的 8 位空间中并没有它。所以 .hex() 办法在做进制转换的时候，就没有顾虑到这个“1”，间接把 52 位二进制有效数字转换掉就按着原来的格局返回了。因而这个 .hex() 办法即便名义上返回的是一个十六进制数，它小数点前的那一位也永远是“1”，看上面示例：
float.fromhex('0x1.8p+1') == float.fromhex('0x3.0p+0')
个别咱们用十六进制迷信计数法来示意 3.0 这个数时，都会这么写“0×3.0p+0”。然而 Python 会这么写“0×1.8p+1”，即“1.1000”小数点右移一位变成“11.000”——的确还是 3.0。就是因为这个 1 是间接遗传自二进制格局的。

而为了回应人们在某些情况下对这个精度问题难以忍受的情绪，Python 提供了另一种数字类型——Decimal。他并不是内建的，因而应用它的时候须要 import decimal 模块，并应用 decimal.Decimal() 来存储准确的数字。这里须要留神的是：应用非整数参数时要记得传入一个字符串而不是浮点数，否则在作为参数的时候，这个值可能就曾经是不准确的了

而后为了更直观地体现，人们又开始用无限小数的模式示意有理数（分数）。而其中从某一位开始前面全是 0 的非凡状况，被称为有限小数（没错，无限小数才是本体）。但因为很多时候咱们并不需要有限长的小数位，咱们会将有理数保留到某一位小数便截止了。前面多余小数的舍入形式便是“四舍五入”，这种形式较间接截断（round_floor）的误差更小。在二进制中，它体现为“0 舍 1 入”。当咱们舍入到某一位当前，咱们就能够说该数准确到了那一位。如果认真领会每一位数字的含意就会发现，在以求得有限小数位下尽可能准确的值为目标状况下，间接截断的舍入形式其实毫无意义，失去的那最初一位小数也并不准确。例如，将 0.06 舍入成 0.1 是准确到小数点后一位，而把它舍入成 0.0 就不算。因而，不论是在双精度浮点数保留 52 位有效数字的时候，还是从双精度浮点数转换回十进制小数并保留若干位有效数字的时候， 对于最初一位有效数字，都是须要舍入的 。

这就是为什么最初常常变得起因，想想 0 的最终存储时的值是 0.00000000000000000001 这种状况，是不是一下就直观了很多。

下图是一个（0,1）之间的数轴，下面用二进制宰割，上面用十进制宰割。比方二进制的 0.1011 这个数，从小数点后一位一位的来看每个数字的意义：结尾的 1 代表真值位于 0.1 的右侧，接下来的 0 代表真值位于 0.11 的左侧，再接下来的 1 代表真值位于 0.101 的右侧，最初的 1 代表真值位于 0.1011 的右侧（蕴含正好落在 0.1011 上这种状况）。应用 4 位二进制小数示意的 16 个不同的值，除去 0，剩下的 15 个数字正好能够均匀散布在（0,1）这个区间上，而十进制只能均匀散布 9 个数字。显然 4 位二进制小数较于 1 位十进制小数将此区间划分的更细，即精度更高

正文完