为什么0.1 + 0.2不等于0.3?一次讲透计算机的数学“Bug”

出大事了!0.1 + 0.2 居然不等于 0.3,Python我再也不敢用了… 说到底,浮点数的锅,不是Python独有的锅,Java、C++、JavaScript 甚至 Excel 都中这个招。你不能不信它,但也不能完全信它。当我们知道它的脾气,就能少踩很多坑。 阅读详情

01 引言

0.1+0.2≠0.3这样问题在程序界,可能大加都知道结论,也可能知道如何规避。但是到底是什么原因呢?

当然,我们都知道这是计算机底层二进制的问题。但是为何会这样呢?我们一起看看吧。

02 情景复现

2.1 JavaScript

在任意的浏览器,调出开发者模式,在控制台输入:

console.info(0.1+0.2);
console.info(0.3);
console.info(0.1+0.2 == 0.3);

下图为谷歌浏览器案例:

我们发现0.1+0.2 == 0.3返回的结果是false。而0.1+0.2=0.30000000000000004和0.3确实不相等。

2.2 Java

@Test
void test01(){
    System.out.println(0.1 + 0.2);
    System.out.println(0.3);
    System.out.println(0.1 + 0.2 == 0.3);
    System.out.println("---------------------------------");
    System.out.println(new BigDecimal(0.1).add(new BigDecimal(0.2)));
    System.out.println(new BigDecimal(0.3));
    System.out.println("---------------------------------");
    System.out.println(new BigDecimal("0.1").add(new BigDecimal("0.2")));
    System.out.println(new BigDecimal("0.3"));
}

基本数据类型和BigDecimal的运算都会出现0.1+0.2≠0.3的问题。

运行结果:

03 原因分析

案例中直接打印,没有问题是因为没有参与二进制位的运算,所以不会有精度的丢失。

要了解精度问题,就要知道在计算机中如何存储二进制位的。案例中的小数为float类型,占4个字节,32位。

3.1 二进制标准

我们知道数学界有无限循环小数,也有无限不循环小数。而计算机要处理写小数,也有统一的国际标准:IEEE 754

它规定了计算机如何用二进制来表示和计算小数(浮点数)。它就像一套世界通用的“小数书写法则”,确保了在不同计算机上,同一个小数能有相同的表示,并且计算结果是可预测的。

在 IEEE 754 出现之前,不同厂商的计算机可能用不同的方式表示小数,导致程序在一台机器上运行正常,在另一台机器上结果却不一样。IEEE 754 统一了这个规则,解决了可移植性和可靠性的问题。而IEEE 754的核心思想就是科学计数法,只不过是二进制中的科学技术法。

float的32位如何划分:

部分符号指数尾数
比特数1 bit8 bits23 bits

符号:

占1个bit,0 表示正数,1 表示负数。也就我们常说的符号位。

指数:

占8个bit,可以标识0~255。为了能表示负指数(比如 2⁻²),IEEE 754 使用了一个“偏置值”。对于单精度,这个值是 127。而指数位(编码指数)的计算是有公式的:编码指数 = 实际指数 + 127

尾数:

占23个bit,指的是有效数字的小数部分。在二进制科学计数法中,任何一个数(除了0)都可以表示为 1.xxxxx × 2^指数。注意,开头的那个 1 是固定的,所以为了节省一个比特,IEEE 754 规定这个 1 是“隐藏的”,不需要存储。我们只需要存储后面的 xxxxx(小数部分)即可。这叫做“隐藏位技术”

3.2 二进制位转化

我们以0.1的二进制位为例:

0.1 * 2 = 0.2 -> 0
0.2 * 2 = 0.4 -> 0
0.4 * 2 = 0.8 -> 0
0.8 * 2 = 1.6 -> 1
0.6 * 2 = 1.2 -> 1
0.2 * 2 = 0.4 -> 0 (从这里开始循环)

二进制位就是将整数位以此拼接。

所以0.1的二进制是:0.000110011001100110011001100110011… (循环节0011)

使用科学计数法(规格化),小数点需要香油移动4位,所以:0.1 = 1.10011001100110011001100... × 2^(-4)。这里的-4就是实际的指数位。那么计算编码指数:编码指数 = -4 + 127 = 123。转化成二进制就是01111011

尾数是23位。只需要从1.10011001100110011001100...× 2^(-4)小数点,向后截取24位。多处的以为是直接舍去还是进一,是有逻辑处理的。处理之后,最后保留23位。

10011001 10011001 1001100 1...第24位是1,后面还有,所以粘滞位为1。根据向最接近的偶数舍入(默认舍入模式):第24位是1,且后面有非零位,所以需要向上舍入(即第23位加1)。所以,原来的23位是:10011001100110011001100
向上舍入后变为:10011001100110011001101

因此,0.1的单精度浮点数表示为:
符号位:0
指数位:01111011
尾数位:10011001100110011001101
组合起来:0 01111011 10011001100110011001101

可视化展示:

31  30    23  22                                      0
┌───┬─────────┬───────────────────────────────────────┐
│ 0 │ 01111011│ 10011001100110011001101               │
└───┴─────────┴───────────────────────────────────────┘
 │     │                     │
 │     │                     └── 尾数域 (23 bits)
 │     │                         - 存储规格化后的小数部分
 │     │                         - 隐藏位为1(不存储)
 │     │
 │     └── 指数域 (8 bits)
 │         - 编码值: 123 (二进制 01111011)
 │         - 实际指数: 123 - 127 = -4
 │
 └── 符号位 (1 bit)
     - 0 表示正数

让我们验证这个位图确实表示约等于 0.1 的值:

  • 符号 = (-1)⁰ = +1
  • 指数 = 2⁻⁴ = 1/16
  • 尾数 = 1 + (1×2⁻¹ + 0×2⁻² + 0×2⁻³ + 1×2⁻⁴ + …)

计算尾数的十进制值:

1.10011001100110011001101₂ = 
1 × 1 + 
1 × 0.5 + 
0 × 0.25 + 
0 × 0.125 + 
1 × 0.0625 + 
1 × 0.03125 + 
0 × 0.015625 + 
0 × 0.0078125 + 
1 × 0.00390625 + 
1 × 0.001953125 + 
... (继续所有23位)

最终结果 ≈ 1.600000023841858
乘以指数部分:1.600000023841858 × 2⁻⁴ = 0.10000000149011612

3.3 位计算

计算0.1+0.2

由上面的计算0.1=1.10011001100110011001101₂,实际指数为-4。

同理可以算出:0.2 = 1.10011001100110011001101₂,实际指数为-3。

将实际指数调整相同:

0.1 = 0.110011001100110011001101 × 2⁻³

0.2 = 1.10011001100110011001101 × 2⁻³

计算:

text

  0.110011001100110011001101  (调整后的0.1)
+ 1.10011001100110011001101   (0.2)
─────────────────────────────
 10.011001100110011001100111

规格化处理后:1.0011001100110011001100111 × 2⁻²

最终舍入处理得到:1.00110011001100110011010 × 2⁻²

验证结果:

1.00110011001100110011010₂ = 
1 × 1 + 
0 × 0.5 + 
0 × 0.25 + 
1 × 0.125 + 
1 × 0.0625 + 
0 × 0.03125 + 
0 × 0.015625 + 
1 × 0.0078125 + 
1 × 0.00390625 + 
0 × 0.001953125 + 
... (继续所有23位)

最终结果 ≈ 1.199999928474426269531250000
乘以指数部分:1.199999928474426269531250000 × 2⁻² = 0.299999982118606567382812500

而0.3在计算机的存储:0.300000011920928955078125。所以值会不相等。

可以通过这个转化工具直接查看:

地址:https://www.h-schmidt.net/FloatConverter/IEEE754.html

04 小结

计算机底层的东西比较晦涩难懂,如有问题还挺多多包含。上面的Java案例中BigDecimal不同的构造,保存的值不一样。

@Test
void test02(){
    System.out.println(new BigDecimal("0.3"));
    // 0.3

    System.out.println(new BigDecimal(0.3));
    // 0.299999999999999988897769753748434595763683319091796875
}

所以使用的BigDecimal构造的时候需要慎重,尽量使用字符串参数的构造函数。

小数、二进制与浮点存储:0.1+0.2为何不等于0.3 小数是位值制在整数右侧的延伸,而计算机用有限二进制位表示数值,这决定了十进制小数与二进制浮点之间并非一一对应。理解进制转换、规格化、阶码与尾数,以及IEEE 754的舍入规则,是定位浮点数精度的基础。它直接影响金额计算、测量读数、科学计算和跨平台数据交换的可靠性,也解释了0.1+0.2为何得到0.30000000000000004。围绕小数概念、十进制转二进制、单双精度存储和精度丢失展开的梳理,可帮助在工程中判断何时用整数、定点或浮点,并建立更稳妥的数值处理习惯。 阅读详情

相关推荐

浮点数的陷阱:你以为的 0.1 + 0.2其实不是 0.3,BigDecimal你真的用对了吗?

在金融和交易系统中,哪怕是一分钱的误差都可能造成巨大损失。然而,很多开发者仍在不经意间落入浮点数的陷阱:看似简单的 0.1 + 0.2,为什么在 Java 中不等于 0.3?本篇文章从底层的 IEEE 754 浮点数标准讲起,剖析误差来源,逐层构建 BigDecimal 使用、格式化控制、精度舍入、判等策略等防线,并结合真实案例总结出一套浮点数处理的实战规范,助你规避金额计算中的隐性风险。

曾经“等你生日那天”都遥远得像未来,如今却可欢愉的挥手说“下个十年见” 13万+

为什么 0.1+0.2 不等于 0.3

位),而在这种格式下无法精确表示某些小数,因此在进行计算时会出现精度误差。中,这些小数会被转换成最接近它们的可表示值,然后再进行计算。被转换成的值可能会存在精度误差,导致它们的和不等于。都是无限循环小数,无法用二进制精确地表示。中采用的是双精度浮点数格式(

weixin_42560424的博客 3029

散户逆袭神器:用通达信DIY指数发现下一个光伏储能(附龙头股筛选模板)

本文详细介绍了如何利用通达信软件的自定义指数功能,构建个人专属的行业监控工具,以发现类似光伏储能这样的潜力赛道。文章提供了从零开始的指数编制步骤、核心的龙头股筛选模板,以及五个关键的数据校验技巧,帮助散户投资者实现机构级的行业分析与机会挖掘,有效提升投资决策能力。

w3x4y的博客 486

0.1+0.2 为什么不等于0.3

0.1+0.2的计算过程 1、十进制转成二进制 在JS内部所有的计算都是以二进制方式计算的。所以运算 0.1+ 0.2 时要先把 0.1和 0.2 从十进制转成二进制。 0.1转化成二进制的算法: 0.1*2=0.2======取出整数部分0 0.2*2=0.4======取出整数部分0 0.4*2=0.8======取出整数部分0 0.8*2=1.6======取出整数部分1 0.6*2=1.2======取出整数部分1 接下来会无限循环 0.2*2=0.4======取出整数部分..

cherryfef的博客 1万+

Flowable多数据源实战:从配置到指定Schema的避坑指南

本文详细介绍了Flowable多数据源配置的实战指南,包括基础配置、数据源Bean创建、指定Schema的进阶配置以及常见问题排查。通过具体代码示例和避坑建议,帮助开发者高效实现多租户系统中的工作流引擎集成,特别强调了schema设置和事务管理的注意事项。

weixin_30824599的博客 486

代码审计工具学习之Seay(安装以及初步认识)

目录 1.1名词解释 1.2代码审计的重要性 1.3代码审计的步骤 1.4代码审计的内容 1.5常见的代码审计工具 2 Seay 2.1什么是Seay 2.2Seay的安装过程 3典型漏洞分析 3.1什么是命令注入漏洞 3.2 如何理解命令注入漏洞 3.3 如何防御命令注入漏洞 4 利用工具对命令注入漏洞进行分析 4.1DVWA靶场命令注入漏洞分析 4.2 Pikachu靶场命令注入漏洞分析 1.1名词解释 软件代码审计是对编程项目中源代码的全面...

weixin_52515588的博客 2万+

js 为什么0.1+0.2不等于0.3

当程序员在使用浮点数进行计算逻辑处理时,不注意,就可能出现问题, 记住,永远不要直接比较俩个浮点的大小 这个属于数字运算中的精度缺失的问题 在0.1 + 0.2这个式子中,0.1和0.2都是近似表示的,在他们相加的时候,两个近似值进行了计算,导致最后得到的值是0.30000000000000004, 此时对于JS来说,其不够近似于0.3,于是就出现了0.1 + 0.2 != 0.3 这个...

weixin_30500289的博客 704

DaVinci配置DID之二:工具链配置

本系列主要基于DaVinCi工具链来展开具体DID读写的配置以及最终实现。1,CDD准备2,工具链配置3,代码实现4,验证结果本文讲述流程2话不多说,走你~博主也是AutoSar小白,如果哪里表达的有问题,还请大佬们指点指点哈。接下来,让我们在下章关于代码具体实现的博文再相会哈~

weixin_48498880的博客 5743

17、为什么0.1 + 0.2 不等于 0.3

再用2去除商,又会得到一个商和余数,如此进行,直到商为小于1时为止,然后把先得到的余数作为二进制数的低位有效位,后得到的余数作为二进制数的高位有效位,依次排列起来。具体做法是:用2乘十进制小数,可以得到积,将积的整数部分取出,再用2乘余下的小数部分,又得到一个积,再将积的整数部分取出,如此进行,直到积中的小数部分为零,此时0或1为二进制的最后一位。浮点数相加时,需要先比较指位数是否一致,如果一致则小数位直接相加,如果不一致,要先把指位数调成一致的,指位数小的向大的调整。转成浮点数形式的二进制。

天界程序员的博客 2287

GJB设计开发各阶段的文件和记录要求

GJB设计开发各阶段的文件和记录要求

Abel的博客 4058

3D打印机控制系统设计:基于MATLAB的3D打印机运动学建模、轨迹规划和控制

控制实现:在控制实现中,需要将轨迹规划的结果转化为实际的控制指令,控制3D打印机按照规划的轨迹进行运动。3D打印机的运动学建模:3D打印机的运动学建模是指将3D打印机的机械结构、传动系统和运动控制部件等抽象成数学模型,以便于进行控制系统的设计和分析。轨迹规划:轨迹规划是指根据3D模型的几何形状和打印机的运动学模型,计算出打印机需要执行的运动轨迹,以便于实现所需的打印效果。控制实现:控制实现是指将轨迹规划的结果转化为控制指令,控制3D打印机按照规划的轨迹进行运动。

走向CTO的路上... 2475

【操作系统】为什么 0.1 + 0.2 不等于 0.3 ?

一、为什么负数要用补码表示? 以 int 类型的数字作为例⼦,int 类型是 32 位的,其中最⾼位是作为「符号标志位」,正数的符号位是 0 ,负数的符号位是 1 ,剩余的 31 位则表示⼆进制数据。 那么,对于 int 类型的数字 1 的⼆进制数表示如下: ⽽负数就⽐较特殊了点,负数在计算机中是以「补码」表示的,所谓的补码就是把正数的⼆进制全部取反再加 1,⽐如 -1 的⼆进制是把数字 1 的⼆进制取反后再加 1,如下图: 那么,为什么计算机要⽤补码的⽅式来表示负数?**在回答这个问题前,我们假设不.

flyersboy的博客 3652

工作之余的随想:AI 会终结 SAP 顾问吗?

本文是笔者工作之余的一些胡思乱想。昨晚(准确的说是今日凌晨),我又熬了一个夜。没办法,接到一个影响客户项目上线的紧急 incident,花了我好长时间,竟然一点头绪都没有。苦苦思索的过程,时间过得飞快。一转眼就晚上11:30 了。要说我 2007 年还在研三实习期间,就进入了 SAP 行业,到今天已经摸爬滚打 18 年了,按理说也算身经百战了,可以说处理过很多 SAP 客户使用系统时遇到的各种稀奇古怪的问题。但即便这样,我也时常在工作中遇到一开始感到无从下手的问题。

2007 年 ~ 2025 年,深耕 SAP 技术 18 年 1266

0.1+0.2不等于0.3

关于计算机中0.1+0.2不等于0.3的问题 先看一下浏览器给出的结果: 可以看到我们的浏览器在运算0.1+0.2的时候是得不到0.3的。 那么为什么? 这是因为在我们的JavaScript语言中,内部的计算都是采用二进制进行计算的。那么我们在进行0.1+0.2时需要先做一个进制转换。 十进制转二进制非小数采用除二取余,小数采用乘二取整。 0.1的二进制:0.0001 1001 1001 1001… 0.2的二进制:0.0011 0011 0011 0011… 它们的二进制都是无穷的。在我们的现代浏览器中

将心_的博客 613

SpringBoot整合LangChain4j实现RAG检索实战详解

本文介绍了使用LangChain4j框架在Java生态中构建RAG(检索增强生成)应用的最佳实践。作为最接近Python LangChain的Java实现,LangChain4j提供了文档解析、向量化存储到检索增强的全套组件,并与SpringBoot深度集成。文章通过电商智能客服场景,详细演示了从零搭建RAG系统的完整流程:包括使用PostgreSQL+pgvector作为生产级向量数据库、文档加载与向量化处理、声明式AI服务实现以及查询压缩、结果重排等进阶优化技巧。同时对比了内存模式与生产级向量库的差异,

分享AI、区块链技术及应用,未来已来 433

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

0.1加0.2为什么不等于0.3

摘要: JavaScript中0.1 + 0.2 !== 0.3的问题源于二进制浮点数精度限制。由于0.1、0.2等十进制小数在二进制中是无限循环数,而计算机存储时会截断,导致计算误差。解决方案包括: 容差比较:使用Number.EPSILON允许微小误差; 整数转换:先转为整数运算再还原; 四舍五入:通过toFixed控制小数位; 高精度库:如decimal.js处理金融计算。 面试时可解释为IEEE 754标准下二进制存储的固有缺陷,并举例说明解决方案。

林恒的博客 369

Statistics and Machine Learning Toolbox

Statistics and Machine Learning Toolbox(带书签),MATLAB统计学习工具

Python跟我说0.1+0.2!=0.3,难道这么多年的数学白学了?

问题 今天闲来无事在IDLE中计算了一下0.1 + 0.2,结果让我大吃一惊,竟然等于0.30000000000000004,纳尼?虽然只是小数点后面第十七位多了个4,但是这也令我陷入深深的思考,难道我这么多年的数学白学了? 我们先来看一下程序运行的结果: 当然有些同学可能会想这会不会是一个bug呢?那么我们来做一些测试: 这段程序大致的意思就是当i < 1时,i会加0.1,然后将每一个i的值都打印出来。看到结果,大家应该不会说python有那么多的bug吧,这里面似乎有着不为人知的秘密呢。 解惑

m0_46376148的博客 6340

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

解决0.1+0.2不等于0.3的精确度提高函数

解决0.1+0.2不等于0.3的精确度提高函数加法函数,用来得到精确的加法结果 加法函数,用来得到精确的加法结果 //说明:javascript的加法结果会有误差,在两个浮点数相加的时候会比较明显。这个函数返回较为精确的加法结果。 //js-bug:0.1+0.2 = 0.30000000000000004 //调用:accAdd(arg1,arg2) //返回值:arg1...

runjieli的博客 546

0.1 + 0.2 为什么不等于 0.3?答不上来的都挂了

这个问题你可能在面试、线上 Bug、甚至随手写 Demo 的时候都见过:1// false0.10.2这篇文章按“现象 → 原因 → 解决 → 面试回答”的顺序,把它讲透。

Cf2ISR5d3的博客 178

JS中关于0.1+0.2 !==0.3 和0.1+0.7!==0.8的问题

** JS中关于0.1+0.2 !==0.3 和0.1+0.7!==0.8的问题 ** 在js中,0.1+0.2不会等于0.3,而是等于: 在js中,0.1+0.7不会等于0.8,而是等于: JS中数字运算时,有一个叫做 数字运算中的精度缺失的问题 要弄清这个问题的原因,首先我们需要了解下在计算机中数字是如何存储和运算的。在计算机中,数字无论是定点数还是浮点数都是以多位二进制的方式进行存储的。...

weixin_44374408的博客 4760

0.1+0.2!=0.3, why?

通常情况下,在进行浮点运算时,会出现一些“匪夷所思”的结果。我们都知道,1/3 等于 0.333…(无限循环),0.1 + 0.2 等于 0.3,但 P...

青春不老,奋斗不止! 1203

0.1+0.2为何不等于0.3:二进制小数转换与IEEE 754浮点精度

浮点数精度问题常从 0.1 + 0.2 ≠ 0.3 开始被感知,其底层是十进制小数与二进制表示之间的进制转换差异。十进制小数转二进制采用乘 2 取整,若最简分数分母含非 2 因子,就会形成无限循环小数,写入有限位存储时只能截断舍入,误差由此进入 IEEE 754 的符号位、阶码和尾数。理解有限性判据与循环节,比死记转换步骤更有技术价值:它能解释浮点数为何不能直接用 == 比较,也能指导金额、坐标、计时等场景选择 Decimal、整数分或误差阈值。在这条主线下,结合 Python Fraction 的精确有理

weixin_42116058的博客 224

原来 0.1*0.2!=0.02

今天老大一本正经的跟我说要交给我一个重大任务。解决关于0.1*0.2的问题。 0.1*0.2不就等于0.02吗??!!一个小学生都知道的答案,但是程序告诉你0.1*0.2并不是0.02。 事实上,不仅...

QDY5945的博客 1112

计算机中0.125的10进制是,十个0.1加起来 等于0.9999999999999999?

人们通常不会怀疑计算机在数学计算上的结果,毕竟,如果连数都算不对,那还叫什么“计算机”啦?其实,有个简单的题目就能让计算机算错,不信我们试试看。如果你用Chrome浏览器的话,按下F12(在Mac上要按Command+Option+I)可以打开一个“开发者工具”窗口,然后点上面的“Console”标签,你会看到一个控制台窗口,在里面输入“0.1+0.1+0.1+0.1+0.1+0.1+0.1+0....

weixin_42367472的博客 900

0.1+0.2=?在前端里,告诉你:≠0.3 !

今天,我来算一道"小学"数学题:0.1+0.2=? 按正常的数学逻辑来计算的话,0.1+0.2当然=0.3啦!但是,咱们也都不是什么小孩子了,都走上了各行各业,那么前端程序员要告诉你一个事!0.1+...

clhq71932的博客 1605

浮点数存储揭秘:为什么0.1+0.2不等于0.3?从FP32/FP64看精度问题

本文深入解析了浮点数在计算机中的存储机制,以经典的0.1+0.2不等于0.3为例,揭示了FP32(单精度)和FP64(双精度)格式因二进制表示和有限内存存储所固有的精度问题。文章详细拆解了IEEE 754标准下的浮点数内存结构,并探讨了在金融计算、科学模拟等场景中的误差陷阱与规避策略。

u6v7w8x的博客 424
上一篇: 百度统计、Google Analytics平替开源网站分析工具:Umami
下一篇: SpringBoot邮件发送怎么玩?比官方自带的Mail更好用的三方工具
智_永无止境
博客等级 码龄10年 803粉丝 406原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

智_永无止境

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值