一个做电商的朋友对账,发现订单金额加起来比实际支付少了一分钱。代码很简单,单价 0.1 元,数量 3,0.1 * 3 打印出来是 0.30000000000000004,再四舍五入到两位小数,有时候进位、有时候不进,几十万单累积下来就差了几分。他去搜“浮点数精度”,看到一堆“不要用 float 存钱”的结论,但没人告诉他为什么,也没人说清楚到底该用什么。
这篇不讲玄学,直接把一个 double 的 64 位拆开,看 0.1 到底被存成了什么,误差从哪来,为什么 2 的 53 次方之后整数开始丢,最后给几条能落地的写法。浮点数不是“不准”,它是在有限位宽下对实数做的一种近似,知道近似的规则,就能预测它在哪里出错。
现象:0.1 加 0.2 得到一长串小数
打开浏览器的控制台,输入 0.1 + 0.2,回车,得到 0.30000000000000004。再输入 0.1 + 0.2 === 0.3,得到 false。这不是 JavaScript 的 bug,Python、Java、C 的 double 都一样,只要用 IEEE 754 的双精度浮点,结果就是这个。Python 里 0.1 + 0.2 显示 0.30000000000000004,C 里用 %.17g 打印也是同一个值。
很多人第一次遇到会尝试“修一下”:round(0.1 + 0.2, 2) 得到 0.3,看起来好了。但把数量、税率、折扣、运费乘进去,误差会被放大,round 只能把表面抹平,不能把底层的近似变成精确。更麻烦的是,误差不是每次都朝同一个方向,有时多一点,有时少一点,累计之后就可能跨过四舍五入的边界。
还有一个反直觉的现象:0.1 单独打印出来是 0.1,看起来存得很准。这是因为打印函数做了“最短往返”处理,只显示能唯一还原这个浮点数的最短十进制串,并不代表内存里就是精确的 0.1。想看到真面目,得用 format 打到 17 位,或者直接看十六进制。
前端的价格展示也常踩这个坑。后端返回 19.99,前端用浮点乘数量、打折、加运费,最后 toFixed(2),大多数时候没问题,偶尔会显示 19.98 或 20.00。测试同学报 bug,开发复现不了,因为差异取决于具体的数值组合。这类问题不能靠“多试几次”,要让金额从接口到展示全程走整数分,展示层才做除法和小数格式化。
表格软件里也会看到类似现象。在单元格里输入 =0.1+0.2,显示两位小数时是 0.30,看起来正常;把小数位数调到 15 位以上,就会露出 0.30000000000000004 的尾巴。很多“公式算错了”的投诉,其实是显示位数掩盖了浮点误差。判断有没有误差,要把显示精度调高,或者用软件提供的“精确计算”选项。
场景走查:十进制的小数点,二进制接不住
十进制里,1 除以 3 是 0.3333……,写不完,只能近似。二进制里也有类似的“写不完”:1 除以 10 等于 0.000110011001100……,循环节是 0011,永远不结束。原因很朴素,10 的质因数是 2 和 5,二进制只能表示分母是 2 的幂的分数。0.5、0.25、0.125 都能精确表示,0.1、0.2、0.3 都不行。就像十进制写不完 1/3,二进制也写不完 1/10。
既然写不完,计算机只能截断到某个长度。IEEE 754 规定了几种格式,最常用的是 binary64(双精度,C 里的 double、JavaScript 的 Number)和 binary32(单精度,C 里的 float)。binary64 用 1 位符号、11 位指数、52 位尾数;binary32 用 1 位符号、8 位指数、23 位尾数。尾数决定有效数字的多少,指数决定能表示多大、多小的数。
浮点数的值和科学计数法一样,写成“符号 × 尾数 × 2 的指数次方”。规格化数的尾数约定在 1 到 2 之间,整数部分的 1 是隐含的,不存进那 52 位里,所以实际有效位数是 53 位。指数用偏移量表示,binary64 的偏移是 1023,存进去的 11 位值减去 1023 才是真正的指数。这样指数可以是负数,不需要单独的符号位。
特殊值也占了一些编码。指数全 0、尾数非 0 表示次正规数(subnormal),用来表示比最小规格化数还小的值;指数全 1、尾数全 0 表示无穷大;指数全 1、尾数非 0 表示 NaN(Not a Number,不是数)。剩下的才是普通数值。这套编码不是随便定的,它让浮点数的比较可以用整数比较的硬件来完成,也让 0 有正零和负零两种写法。
为什么指数要用偏移而不是补码?因为这样编码后,两个正浮点数的大小顺序和它们的位模式按无符号整数比较的顺序一致。硬件做浮点比较时,可以先按整数比一比,再处理符号和特殊值,省事很多。这也是为什么浮点的位模式看起来“指数在高位、尾数在低位”,不是随意排的。
有效位数可以用对数估算。53 位二进制大约相当于 53 乘以 log10(2),约等于 15.95 位十进制有效数字,所以 double 能可靠表示 15 位,勉强表示 17 位。23 位的 float 大约是 6.92 位十进制,所以 float 通常只有 6 到 7 位有效数字。这个估算能帮你判断一个计算该用哪种精度,而不是凭感觉选。
拆开一个 double:0.1 到底存了什么
用 Python 的 struct 把 0.1 打包成 8 字节,再打印十六进制,得到 3fb999999999999a。这 16 个十六进制字符就是 64 位。拆开看:最高位是 0,表示正数;接下来 11 位是 011 1111 1011,也就是十六进制的 3fb,换成十进制是 1019;剩下的 52 位是 1001 1001 ... 1010,也就是 0x999999999999a。
指数 1019 减去偏移 1023,等于 -4。尾数部分 0x999999999999a 除以 2 的 52 次方,约等于 0.6,加上隐含的 1,尾数是 1.6。所以这个数约等于 1.6 乘以 2 的 -4 次方,也就是 1.6 除以 16,等于 0.1。注意这里说的是“约等于”,因为 0x999999999999a 本身就是一个截断后的值,不是精确的 0.6。
把十进制 0.1 转成二进制的展开式,是 0.000110011001100……,循环节 0011 无限重复。binary64 只有 53 位有效数字,截断之后必然带一个微小的误差。这个误差的量级大约是 2 的 -56 次方,换算成十进制在 10 的 -17 次方附近。所以 0.1 在内存里实际存的是 0.1000000000000000055511151231257827……,打印时被最短往返算法显示回 0.1。
两个近似值相加,误差也相加,结果就变成了 0.30000000000000004440892098500626……,最短往返显示为 0.30000000000000004。而 0.3 单独存进去又是另一个近似值,两者不相等。这不是加法算错了,而是三个数各自都被近似过,近似的位置不一样。
截断也不是简单地“砍掉后面的位”。IEEE 754 默认的舍入模式是“就近舍入,遇到正好一半时取偶数”,简称 round to nearest, ties to even。这样能让误差在统计上互相抵消,也避免总是朝一个方向偏。可以用 Python 的 decimal 模块验证:把 0.1 的浮点值精确打印出来,会得到一长串 55511151231257827021181583404541015625 结尾的数字,这正是 53 位截断后的结果,不是随机的噪声。
同一个十进制数,float 和 double 存出来的位模式不同,误差大小也不同。0.1 在 double 里的误差约 5.5e-18,在 float 里的误差约 1.5e-9。所以做累计计算时,float 往往几千次就开始明显偏移,double 能撑到几十亿次。选精度不是“差不多就行”,要看计算规模和能容忍的误差。
实测:误差、精度上限和特殊值
先看几个能直接复现的数字。下面这段 Python 在本机 3.15 上跑出的结果都是真实的:
print(0.1 + 0.2) # 0.30000000000000004
print(0.1 + 0.2 == 0.3) # False
print(0.1 + 0.2 - 0.3) # 5.551115123125783e-17
print(0.1 * 3) # 0.30000000000000004
print(struct.pack('>d', 0.1).hex()) # 3fb999999999999a
print(struct.pack('>f', 0.1).hex()) # 3dcccccd
第三行那个 5.55e-17 就是误差本身。它很小,但对“必须精确到分”的场景足够致命。第六行的 3dcccccd 是单精度 0.1 的编码,把它解回十进制是 0.10000000149011612,误差比双精度大了好几个数量级。所以做科学计算时用 double,做图形渲染时用 float 省内存,两者不能随便换。
再看整数精度的上限。binary64 的 53 位有效数字意味着,所有绝对值不超过 2 的 53 次方的整数都能精确表示,超过之后就开始丢。2 的 53 次方是 9007199254740992,加一之后还是它自己:
print(float(2**53) + 1.0 == float(2**53)) # True
print(float(2**53) + 1.0) # 9007199254740992.0
print(1e308 * 10) # inf
print(5e-324) # 5e-324
第一行返回 True,说明 2 的 53 次方加一在浮点里根本区分不出来。这也是 JavaScript 的 Number.MAX_SAFE_INTEGER 定为 9007199254740991 的原因。最后一行 5e-324 是最小的次正规数,约等于 2 的 -1074 次方;再小就变成 0。反过来,1e308 乘 10 溢出成 inf,不会报错,只会静默地变成无穷大。
还有一个经常被忽略的行为:NaN 和任何数比较都返回假,包括它自己。float('nan') == float('nan') 是 False,nan < 1 和 nan > 1 也都是 False。用 NaN 做排序、去重、找最大值时,结果会非常奇怪。判断 NaN 要用 math.isnan,不能写 x == float('nan')。另外,0.0 == -0.0 是 True,但 1 / -0.0 是负无穷,符号在除法里又起作用了。
无穷大也不是“一个很大的数”。inf 加一个有限数还是 inf,inf 减 inf 变成 NaN,inf 乘 0 也是 NaN。它更像是一个状态标记,表示“这个结果超出了可表示范围”,而不是参与运算的普通数值。业务代码里一旦出现 inf,通常说明上游有除以零、数据溢出或单位换算错误,应该当成异常来查,而不是继续算下去。
现象对照表
| 现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 0.1 加 0.2 得到 0.30000000000000004 | 0.1、0.2、0.3 都无法用二进制有限位表示,各自被近似 | 确认是否必须精确,能否改用整数分或十进制类型 |
| 金额累计后差几分钱 | 浮点误差随运算放大,四舍五入跨过边界 | 查金额字段类型,改为以分为单位的整数或 Decimal |
| 2 的 53 次方之后整数加一不变 | 双精度只有 53 位有效数字,低位被舍入 | 看数值是否超过安全整数范围,改用字符串或大整数 |
| 两个看起来相等的数比较为假 | 两边是不同近似值,直接相等比较不可靠 | 改用容差比较,或比较经过统一量化的值 |
| 单精度大量累加后明显偏移 | float 有效位少,每次累加都丢低位 | 换 double,或用 Kahan 求和等补偿算法 |
| 排序或去重时 NaN 行为异常 | NaN 参与的任何比较都返回假 | 显式用 isnan 过滤,别依赖比较运算符 |
| 序列化再读回,末位变了 | 十进制文本往返发生二次舍入 | 用十六进制或最短往返格式,确认精度损失点 |
| 大数计算突然变成 inf | 指数位溢出,浮点不抛异常 | 检查输入范围,必要时用对数或分段计算 |
边界与代价
浮点最大的代价是“不精确”,而且这种不精确不满足很多直觉上的代数规律。加法不满足结合律:(0.1 + 0.2) + 0.3 和 0.1 + (0.2 + 0.3) 可能得到不同的结果;乘法对加法的分配律也可能因为舍入而失效。编译器如果开了快速数学优化,甚至可能假设这些规律成立,重排你的表达式。科学计算里做结果复现,要控制编译选项、运算顺序和是否使用融合乘加(FMA)。
第二个代价是“有效数字”和“小数位数”不是一回事。double 大约有 15 到 17 位有效十进制数字,但这不是说小数点后能保留 17 位。一个大数加一个小数,小数可能被整个吞掉:1e16 + 1 还是 1e16。做累加时,如果数组里既有很大的值又有很小的值,先加小的、再加大的,误差会小一些;反过来就会丢信息。
第三个代价是特殊值和边界行为。除以零得到无穷而不是异常,0 除以 0 得到 NaN,溢出得到无穷,下溢得到 0 或次正规数。这些行为在图像处理、物理仿真里很方便,但在业务系统里很危险,因为它们不会中断流程,只会把错误悄悄传播到下游。看到 inf 或 NaN 时,往往已经离出错点很远了。
第四个代价是性能和可移植性的权衡。浮点运算通常有专门的硬件单元,加法和乘法很快,但除法、开方、三角函数慢一些;次正规数在某些处理器上会触发慢路径;不同平台的舍入模式、扩展精度、FMA 支持都可能不同。同一段代码在 x86 和 ARM 上跑出末位不同的结果,是常见现象,不一定是 bug。要求严格一致的场景,要用定点数或整数运算。
那金额到底怎么存?最稳妥的是用整数的最小货币单位,比如人民币用分,美元用美分,数据库存 BIGINT,计算全程用整数,展示时再除以 100。需要复杂税率、分期、汇率时,用十进制定点类型,比如 Java 的 BigDecimal、Python 的 decimal.Decimal、C# 的 decimal。它们的代价是慢、占内存、API 啰嗦,但能保证十进制下的精确运算和明确的舍入规则。用浮点存钱,迟早要在某个对账日付出代价。
数据库里的 DECIMAL 和 NUMERIC 也是定点类型,不是浮点。它们按十进制存有效数字和小数位数,查询和计算都在十进制域完成。ORM 或驱动如果把它们映射成编程语言的 float,精度在读出那一刻就已经丢了,后面的计算再精确也补不回来。排查金额问题时,要一路看到驱动层,确认中间没有经过浮点。
如果只是做展示或近似计算,浮点完全够用,不必因噎废食。比较两个浮点数时,别写 a == b,写 abs(a - b) < 1e-9 这样的容差;容差选多大,取决于业务能接受多少误差,不要拍脑袋抄一个 1e-6。Python 的 math.isclose 提供了相对容差和绝对容差两个参数,比手写更清楚。需要排序时,先量化到固定小数位再比,避免末位噪声影响顺序。
还有一点要承认:浮点数的十进制显示是“翻译”,不是“原样”。同一个 double 值,用不同语言、不同格式化函数打印,可能出现不同的末位。做日志比对、快照测试时,如果直接比浮点的十进制字符串,很容易出现“本机通过、CI 失败”。要么在断言里带容差,要么统一格式化成固定位数,别让显示层的不一致被当成逻辑错误。
当天能自己验证的练习
- 在 Python 里打印
0.1 + 0.2,再用format(0.1 + 0.2, '.17f')看完整误差,最后用decimal.Decimal('0.1') + decimal.Decimal('0.2')对比精确结果。 - 把 0.1、0.2、0.3 分别用
struct.pack('>d', x).hex()打成十六进制,手工拆出符号位、指数位和尾数位,验证指数偏移是不是 1023。 - 写一个循环,把 0.1 累加 1000 次和 10000 次,打印结果与理论值的差;再用整数分累加同样的次数,比较误差。
- 构造
float('nan'),测试它和自身、和 1 的大小比较,再用math.isnan判断,观察结果差异。 - 用单精度
struct.pack('>f', 0.1)往返,记录误差;再把同样的累加用 float32 做一遍,看偏移比 double 大多少。
小结与下一篇
浮点数用符号、指数、尾数三部分表示实数,位数有限,所以只能近似。0.1 和 0.2 在二进制里是无限循环小数,存进去就被截断,相加后误差暴露出来。双精度有 53 位有效数字,安全整数上限是 2 的 53 次方减一;单精度更少。金额用整数分或十进制定点,比较用容差,累加注意顺序,看到 inf 和 NaN 要当错误处理。
到这里,整数和小数的存储都讲完了,但内存里存的还不止数字。文本、emoji、中文、日文也要变成字节,而同一段字节用不同编码解释,出来的字可能完全不同。下一篇讲同一个字为什么一会儿乱码一会儿正常:字符编码,把 Unicode、UTF-8 和 GBK 的关系理清楚。