python精确计算
 
在python中浮点数计算是不精确的的，这是因为小数以二进制形式表示时的有穷性导致的。想要精确计算浮点数，需要调用decimal这个模块，decimal是十进制类型
 

 decimal.Decimal(x) #x可以是一个整数或字符串，但不能是浮点数
 
 
 
 
  
 
   
import decimal
 a = decimal.Decimal(9876)
 b = decimal.Deciaml(“54321.01234567898754321”)
 a + b
 Decimal(‘64197.012345678987654321’)
 
  
 
 
 
 
decimal.Deciaml.from_float(x); #x可以是一个浮点数
 
 
 
 
  
 
   
Deciaml.from_float(0.1)
 Decimal(‘0.1000000000000000055511151231257827021181583404541015625’)
 
  
 
 
 
 
 
  
 
   
Decimal.from_float(float(‘nan’));
 Decimal(‘NaN’)
 
  
 
 
 
 
 
  
 
   
Decimal.from_float(float(’-inf’));
 Decimal(’-Infinity’)
 
  
 
 
 
 
Python 中的 float 类型使用C语言的 double 类型进行存储。 float 对象的值是以固定的精度（通常为 53 位）存储的二进制浮点数，由于 Python 使用 C 操作，而后者依赖于处理器中的硬件实现来执行浮点运算。 这意味着就浮点运算而言，Python 的行为类似于许多流行的语言，包括 C 和 Java。
 
许多可以轻松地用十进制表示的数字不能用二进制浮点表示。例如，之后:
 
 
 
 
  
 
   
x = 1.2
 
  
 
 
 
 
为 x 存储的值是与十进制的值 1.2 (非常接近) 的近似值，但不完全等于它。 在典型的机器上，实际存储的值是：
 
1.0011001100110011001100110011001100110011001100110011 (binary)
 确切地说:
 
1.1999999999999999555910790149937383830547332763671875 (decimal)
 典型的 53 位精度为 Python 浮点数提供了 15-16 位小数的精度。

eg:一个整数*一个小数出现的结果是
 
 
计算机编程语言里浮点数计算会存在精度丢失问题（或称舍入误差），其根本原因是二进制和实现位数限制有些数无法有限表示
 * 以下是十进制小数对应的二进制表示
 *      0.1 >> 0.0001 1001 1001 1001…（1001无限循环）
 *      0.2 >> 0.0011 0011 0011 0011…（0011无限循环）
 * 计算机里每种数据类型的存储是一个有限宽度，比如 JavaScript 使用 64 位存储数字类型，因此超出的会舍去。舍去的部分就是精度丢失的部分。
 
核心方法：实现加减乘除运算，确保不丢失精度
     * 思路：把小数放大为整数（乘），进行算术运算，再缩小为小数（除）
 

  
 
 
 
转载出自https://www.cnblogs.com/SuperLiangG/p/5964439.html

 
 
js浮点数乘法是有误差的，这个问题是在很久以前一次项目计算中发现的，那么接下来就说一下如何修正这个误差。
 
 
下面直接上代码吧，简单来说就是以小数点为基准进行切割，将是浮点数的转为整数进行计算，最后再放大小数点后N倍还原正确计算结果。
 
=========> 比如计算 0.14*10

// 直接答案 1.4000000000000001 这显然不是我们想要的结果

function accMul(arg1, arg2) {

	let m = 0;
	const s1 = arg1.toString();
	const s2 = arg2.toString();

	if (s1.includes('.')) {
		m += s1.split('.')[1].length;
	}

	if (s2.includes('.')) {
		m += s2.split('.')[1].length;
	}

	return Number(s1.replace('.', '')) * Number(s2.replace('.', '')) / Math.pow(10, m);
}

//调用accMul accMul(0.14, 10) 得到 1.4 这才是我们想要的

1 概述
 
浮点数指的是带有小数的数值，浮点运算即是小数的四则运算，常用来测量电脑运算速度。大部份计算机采用二進制（b=2）的表示方法。位(bit)是衡量浮点数所需存储空间的单位，通常为32位或64位，分别被叫作单精度和双精度。
 
2 误差现象
 
console.log(0.1+0.2);    // 输出 0.30000000000000004
console.log(0.15+0.15);  // 输出 0.3
 
console.log(0.7+0.1);    // 输出 0.7999999999999999
console.log(0.6+0.2);    // 输出 0.8
 
console.log(0.3*3);      // 输出 0.8999999999999999
console.log(3*3/10);     // 输出 0.9
 
从以上现象可以看出，并不是所有的浮点数运算都会出问题，只是部分。
 
0.7+0.1 输出有偏差
 
0.6+0.2 输出正确
 
具体是什么原因呢，继续向下看。
 
3 误差原因
 
不仅仅是JS，大多数语言在处理浮点数的时候都会遇到精度问题，准确的说，所有支持二进制浮点数运算（绝大部分都是 IEEE 754 的实现）的系统都存在这个现象。
 其原因就是，在有限的存储空间下，绝大部分的十进制小数都不能用二进制浮点数来精确表示。例如，0.1 这个简单的十进制小数就不能用二进制浮点数来表示。所谓「计算机浮点数」，其实就是二进制的「科学计数法」。在十进制中，科学计数法的形式是：
 
 相应的，二进制的科学计数法就是：
 
 而在有限的存储空间下，十进制小数 0.1 无论如何也不能用这种形式来表示，因此，计算机在存储它时，产生了精度丢失，所以就出现了问题中所描述的现象。
 更详细的可以点击链接查看 https://www.zhihu.com/question/20679634
 
4 解决方案
 
如何解决呢？看这个例子：
 
console.log(0.3*3);      // 输出 0.8999999999999999
console.log(3*3/10);     // 输出 0.9
 
浮点数计算有问题，整数计算是没问题的，那么将浮点转化成整数运算，之后再切回浮点就可以保证没有偏差了
 
注：不推荐js做太多的浮点运算。
 
以下方法可以帮助你修正浮点运算的偏差：
 
// 浮点数求和
function add(a, b) {
    var c, d, e;
    try {
        c = a.toString().split(".")[1].length;
    } catch (f) {
        c = 0;
    }
    try {
        d = b.toString().split(".")[1].length;
    } catch (f) {
        d = 0;
    }
    return e = Math.pow(10, Math.max(c, d)), (mul(a, e) + mul(b, e)) / e;
}
 
// 浮点数相减
function sub(a, b) {
    var c, d, e;
    try {
        c = a.toString().split(".")[1].length;
    } catch (f) {
        c = 0;
    }
    try {
        d = b.toString().split(".")[1].length;
    } catch (f) {
        d = 0;
    }
    return e = Math.pow(10, Math.max(c, d)), (mul(a, e) - mul(b, e)) / e;
}
 
// 浮点数相乘
function mul(a, b) {
    var c = 0,
        d = a.toString(),
        e = b.toString();
    try {
        c += d.split(".")[1].length;
    } catch (f) {}
    try {
        c += e.split(".")[1].length;
    } catch (f) {}
    return Number(d.replace(".", "")) * Number(e.replace(".", "")) / Math.pow(10, c);
}
 
// 浮点数相除
function div(a, b) {
    var c, d, e = 0,
        f = 0;
    try {
        e = a.toString().split(".")[1].length;
    } catch (g) {}
    try {
        f = b.toString().split(".")[1].length;
    } catch (g) {}
    return c = Number(a.toString().replace(".", "")), d = Number(b.toString().replace(".", "")), mul(c / d, Math.pow(10, f - e));
}
 
验证
 
console.log(0.1+0.2);        // 输出 0.30000000000000004
console.log(add(0.1, 0.2));  // 输出 0.3
 
console.log(0.7+0.1);        // 输出 0.7999999999999999
console.log(add(0.7, 0.1));  // 输出 0.8
 
console.log(0.3*3);          // 输出 0.8999999999999999
console.log(mul(0.3, 3));    // 输出 0.9
 
博文部分来自知乎和其它博客，感谢！