完全解析为什么0.1+0.2=0.30000000000000004

已于 2022-03-14 05:09:09 修改
阅读量2.5k 收藏 17
点赞数 13
文章标签： float IEEE 754-1985 double 浮点数
于 2022-03-13 05:45:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yjrguxing/article/details/123358877
版权 
阅读全文根据基础需要20-60分钟

引子

可能因为某一次报错或某次面试，你会接触到这个问题，即
在这里插入图片描述
其实该问题很多语言都存在，你也可以在https://0.30000000000000004.com/了解其他信息，本文主要以Java为例对该问题进行讨论

计算结果多样原因

如果你已经参阅了好几篇讲解0.1+0.2为什么!=0.3的文章，你会发现大家在浮点数的讲解上大同小异，不过最终0.1+0.2的结果却大体分为4种不同的结果，这里的原因是

  • 有些博主以float(单精度浮点数)举例
  • 有些博主以double(双精度浮点数)举例

同时在计算过程中,博主们的计算过程大致为为两类

  • 将0.1与0.2转为实际的二进制浮点数 → 进行二进制浮点数计算 → 计算结果转为十进制
  • 将0.1与0.2转为实际的二进制浮点数 → 将浮点数转回十进制 → 直接进行十进制数计算

所以大家会看到4种不同的计算结果，如果除此4种结果以外还存在其他结果，那么多半是由于粗心在某些步骤出现了计算失误，本篇会带着大家逐步完成其中3种情况的计算，最后一种留作习题用以检验自己的学习成果

需要注意的是，Java本身的计算顺序是
将0.1与0.2转为实际的二进制浮点数 → 进行二进制浮点数计算 → 计算结果转为十进制
所以其他3种情况的结果都不和0.30000000000000004相符

正文

Java中的默认数据类型

我们首先需要知道,Java中的整数默认是int型，小数默认是Double
所以我们可以理解为这是Double型的0.1与0.2相加

到底什么是Double?

Double是符合IEEE_754-1985计算机浮点数标准的双精度浮点数，这一标准也规定了浮点数要以什么样的形式保存在计算机中

10进制转换为浮点数

在 IEEE_754-1985 规范中规定了浮点数的二进制表现形式以及长度限制
长度限制如下

数据类型定义长度
float单精度浮点数32位2进制
double双精度浮点数64位2进制

浮点数的表现形式分为3部分，以上题需求，这里以double为例
在这里插入图片描述

  • 第一部分为符号位，仅占用1位(bit)——0为正，1为负
  • 第二部分为指数位，占用11位,用来存储经偏指数进行计算过后的指数
  • 第三部分为分数部分，占用52位,用来存储分数，分数长度不够后方全部补0直到长度符合要求

下面我们以十进制数0.15625为例，逐步计算将其转为双精度浮点数，来让大家实际了解十进制数如何转为双精度浮点数

符号位

0.15625 很明显是正数，所以符号位为0

指数位

这里我们需要先将十进制数0.15625转为二进制数，即为0.00101

如果你对2进制不了解，可以百度搜索进制转换工具帮助完成这一步，这里不做进制转换工具推荐

之后我们需要以科学计数法的形式表示0.00101，即为1.01 * 2 指数为-3

科学计数法：
把一个数表示成a与10的n次幂相乘的形式（1≤|a|<10，a不为分数形式，n为整数
举例
12的科学计数法表示为:1.2 * 10 指数为1
在二进制中即为把一个数表示成a与2的n次幂相乘的形式（1≤|a|<2，a不为分数形式，n为整数

同时浮点数标准也为不同精度的浮点数规定了固定的指数位偏差，双精度浮点数(double)的固定偏差为1023
此时计算指数与偏差，即(1023) + (-3) = 1020,将1020转为二进制，即为1111111100
此时我们回看指数位的定义，double的指数位长度为11位，（1111111100）长度为10位，所以我们需要在数前补0直到长度为11位，即将1111111100变换为01111111100
所以指数位为 01111111100

分数位

回看上一步得到的科学计数法的表示——1.01 * 2 指数为-3
分数部分即为小数部分 即为1.01中的01，不过由于01的位数太少，我们需要在其后方补0直到满足分数位52位的要求
结果为：0100000000000000000000000000000000000000000000000000
最终进行拼接，即0.15625的双精度浮点数表示为
0011111111000100000000000000000000000000000000000000000000000000

浮点数转换为10进制

大家已经会了10进制如何转为浮点数了，那么大部分人应该已经能推导出浮点数要如何转回10进制了，不过这里依然还是要讲一下
还是以
0011111111000100000000000000000000000000000000000000000000000000为例
首先区分3部分
0 01111111100 0100000000000000000000000000000000000000000000000000
符号位可以确定数为正数，指数位部分2进制转10进制，为1020，double偏指数为1023
1020 - 1023 = -3则指数为-3
分数部分可以简写为01，需要注意的是，这里隐含的前导数固定为1，即可以知道原数为1.01
此时进行计算1.01 * 2 指数为-3，得出结果为0.00101，最后直接2进制转回10进制即可

Double——情况1讨论

这里的情况为，将小数类型以Double处理，计算过程以
将0.1与0.2转为实际的二进制浮点数 → 进行二进制浮点数计算 → 计算结果转为十进制 进行处理

0.1的二进制浮点数

0.1的二进制浮点数为
0011111110111001100110011001100110011001100110011001100110011010
如果你以上方讲解进行转换，会遇到无限循环小数问题，即0.1转为2进制是无限循环小数，这时大家得出的结果应该都为
0011111110111001100110011001100110011001100110011001100110011001
那么为什么这里我的结果和大家不一样呢？因为当分数部分位数不够，即出现分数丢失精度情况时，我们需要做一个操作——舍入
浮点数的默认舍入方式和大家平时理解的四舍五入基本一致，在本情况下直接将最后一位1向前进位1即可

如果你希望对浮点数的舍入进行更多了解，可以自行百度
0.2的二进制浮点数

0.2的二进制浮点数为
0011111111001001100110011001100110011001100110011001100110011010
0.2同样存在舍入操作

浮点数计算

此时我们需要计算
0.1 → 0011111110111001100110011001100110011001100110011001100110011010
+
0.2 → 0011111111001001100110011001100110011001100110011001100110011010
的结果，不过浮点数运算和常规运算不同，我们一步一步进行

对阶——可能影响数据准确

浮点数计算的第一步为对阶，即将参与计算的浮点数的指数位保持一致
需要注意，对阶的原则为小阶向大阶对阶
这里我们首先计算他们的阶码
0.1阶码 → 01111111011 → 1019
0.2阶码 → 01111111100 → 1020
所以我们这里需要做的就是将0.1的阶码+1变为1020
01111111011 → 01111111100
因为阶码的改变，为了不让浮点数表示的数发生改变，分数部分需要向右同步移1位，这里需要注意，分数部分隐含前导数为1，即右移的第一位进来的数是1

如果这一步你没看懂，可以以科学计数法的形式进行思考，即
12 → 1.2 * 10 阶码为1
此时需要将阶码改为2，则分数部分需要进行变动，最终表示变为
0.12 * 10 阶码为2

1001100110011001100110011001100110011001100110011010 变为
1100110011001100110011001100110011001100110011001101
对阶结束时，0.1和0.2的值分别为
0.1 → 0011111111001100110011001100110011001100110011001100110011001101
0.2 → 0011111111001001100110011001100110011001100110011001100110011010

尾数计算(分数计算)

浮点数计算的第二步为直接计算浮点数的第三部分，这里需要注意不要丢失分数部分隐含的前导数
0.1 → 0.1100110011001100110011001100110011001100110011001101
+
0.2 → 1.1001100110011001100110011001100110011001100110011010
=
0.3 →10.0110011001100110011001100110011001100110011001100111
尾数部分计算到这里就结束了，我们接着下一步处理

这里0.1的前导数为0是因为分数部分在对阶的阶段已经右移了1位所以隐含前导数1已经移动到了分数部分的开头
规格化处理——可能影响数据准确

IEEE 754-1985标准要求浮点数的隐含前导数必须为1，但是此时计算结果为
10.0110011001100110011001100110011001100110011001100111
隐含前导数为10，所以我们需要进行规格化处理，让前导数重新变为1
这里我们需要执行的操作为右规，即将分数部分向右移动一位
10.0110011001100110011001100110011001100110011001100111 变为
1.0011001100110011001100110011001100110011001100110011
需要注意，这里最后一位的1被丢掉了，从而会影响数据准确
规格化处理后的分数部分为
0011001100110011001100110011001100110011001100110011
因为分数部分向右移动了一位，所以阶码需要+1
01111111100 → 01111111101

规格化处理分为左规和右规，左规即将分数部分向左移动，右规即将分数部分向右移动
舍入操作

由于规格化处理时导致低位丢失，所以需要进行舍入操作，即
0011001100110011001100110011001100110011001100110011 变为
0011001100110011001100110011001100110011001100110100

溢出判断

这里没有溢出

最终计算结果即为
符号位 0
指数位 01111111101
分数 0011001100110011001100110011001100110011001100110011

结果转为10进制

01111111101 代表指数为1021 带入偏差1023进行计算结果为-2
所以分数小数点需向左移动2位
0011001100110011001100110011001100110011001100110011 变为
0.010011001100110011001100110011001100110011001100110011
转为10进制为：3.00000000000000044408920985006E-1
即 0.300000000000000044408920985006
这就是为什么0.1+0.2=0.30000000000000004的原因

Double——情况2讨论

这里的情况为，将小数类型以Double处理，计算过程以
将0.1与0.2转为实际的二进制浮点数 → 将浮点数转回十进制 → 直接进行十进制数计算 进行处理
0.1和0.2的浮点数可以在上种情况中直接拿来使用
0.1 → 0011111110111001100110011001100110011001100110011001100110011010
0.2 → 0011111111001001100110011001100110011001100110011001100110011010

浮点数转回10进制

0011111110111001100110011001100110011001100110011001100110011010 → 0.100000000000000005551115123126
0011111111001001100110011001100110011001100110011001100110011010 → 0.200000000000000011102230246252

10进制计算

0.100000000000000005551115123126
0.200000000000000011102230246252
0.300000000000000016653345369378
因此最终结果为0.300000000000000016653345369378

Float——情况1讨论

这里的情况是，将小数类型以Float处理，计算过程以
将0.1与0.2转为实际的二进制浮点数 → 将浮点数转回十进制 → 直接进行十进制数计算 进行处理
0.1 → 00111101110011001100110011001101
0.2 → 00111110010011001100110011001101

浮点数转回十进制

00111101110011001100110011001101 → 0.100000001490116119384765625
00111110010011001100110011001101 → 0.20000000298023223876953125

10进制计算

0.100000001490116119384765625
0.20000000298023223876953125
0.300000004470348358154296975
因此结果为0.300000004470348358154296975

到此为止我说的4种情况其中的3种都进行逐步计算，最后一种的情况为

将小数类型以Float处理，计算过程以
将0.1与0.2转为实际的二进制浮点数 → 进行二进制浮点数计算 → 计算结果转为十进制 进行处理

这种情况留作检验阅读本博客的作业，大家可以自己尝试计算一下

参考文章

  1. IEEE 754-1985
  2. Floating Point Math
  3. 浮点数转换工具网站

最后更新于2022年3月14日
原创不易，如果该文章对你有所帮助，望左上角点击关注~如有任何技术相关问题，可通过评论联系我讨论,我会在力所能及之内进行相应回复以及开单章解决该问题.

该文章如有任何错误请在评论中指出，感激不尽，转载请附出处！
个人博客首页：https://blog.csdn.net/yjrguxing ——您的每个关注和评论都对我意义重大

【2023，学点儿新Java-31】测试：整型和浮点型变量的使用 | 附：计算机存储单位（转换关系）| 企业真题：为什么0.1+0.2不等于0.3
追光者♂：记录、分享、总结、提升，现象级专栏《Python从入门到人工智能》作者，无惧黑暗，坚信曙光
07-13 407
本篇综合了变量、运算符和计算机存储单位的重要概念。具体地，介绍了变量的作用和使用方法，涵盖了整型和浮点型变量，并讨论了计算机存储单位的转换。通过本篇内容，你将了解到这些基础概念对编写高效、准确的代码的重要性。
javascript 精度计算/数学运算 mathjs
zihong2019的博客
06-07 1585
Node库/Javascript库 mathjs 目录：Node库/Javascript库 mathjs文档地址（[中文](https://www.mathjs.cn/docs/index.html)|[英文](https://mathjs.org/docs/index.html)）| [github](https://github.com/josdejong/mathjs)配置（ps:可有可无）基本运算一些常量单位换算自定义函数、变量官方扩展案例： 文档地址（中文|英文）| github 配置（ps:可有
为什么0.1+0.2=0.30000000000000004
烟雨星空的博客
11-09 1722
​阅读本文大约需要8分钟... 问题 在计算机的世界里，可能有很多常人无法理解的事情。比如 0.1 0.2 = ？。来，告诉我你的答案。 有的朋友看到这就迫不及待的说，这么简单的问题，很明显等于 0.3 啊，小学生都会算的好伐。你这是在侮辱我的智商？ 好吧，我来告诉你一个打脸的事实，0.1 0.2 还真不等于 0.3 。先别急着反驳我。 打开你的任意一个浏览器（我用chrome做演示），F...
深度剖析0.1 +0.2===0.30000000000000004的原因
weixin_34332905的博客
11-08 357
用一句话概括就是：EcmaScrpt规范定义Number的类型遵循了IEEE754-2008中的64位浮点数规则定义的小数后的有效位数至多为52位导致计算出现精度丢失问题！ 如果你看不懂这句话，仔细阅读本篇博客就对了！ 首先看下10进制转换为2进制的方法。 数字逻辑电路上的算法是 (0.1)10 = （0.0）2。 吐槽一句，大二的专...
[转] 为什么0.1+0.2=0.30000000000000004
S号口袋怪:|
11-19 264
????原文链接 文章讨论了计算机中的浮点运算问题，给出了各种不同语言的浮点输出。 浮点数运算 你使用的语言并不烂，它能够做浮点数运算。计算机天生只能存储整数，因此它需要某种方法来表示小数。这种表示方式会带来某种程度的误差。这就是为什么往往 0.1 + 0.2 不等于 0.3。 为什么会这样？ 实际上很简单。对于十进制数值系统（就是我们现实中使用的），它只能表示以进制数的质因子为分母的分数。10 的质因子有 2 和 5。因此 1/2、1/4、1/5、1/8和 1/10 都可以精确表示
0.1+0.2=0.30000000000000004问题的探究
geshenyisunjie的博客
05-11 518
今天花了一整天的时间复习二进制相关知识，在这里写下这篇blog作为总结！ 为什么“0.1+0.2=0.30000000000000004”？ 首先声明这不是bug，原因在与十进制到二进制的转换导致的精度问题！ 其次这几乎出现在很多的编程语言中：C/C++,Java,Javascript中，准确的说：“使用了IEEE 754浮点数格式”来存储浮点类型(float 32,double 6...
程序里为什么0.1+0.2不等于0.3？
BeanInJ的博客
01-20 704
为什么0.1+0.2不等于0.30.1+0.2新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 0.1+0.2 程序里面0.1+0.2=0.30000000000000004 你好！ 这是你第一次使用 Markdown编辑器
编程语言|Python——为什么0.1+0.2≠0.3（深入理解Python中的浮点数运算）
也许有一天我们再相逢 睁开眼睛看清楚 我才是英雄！
08-01 1237
在python中可以采用采用round()函数，对数据进行处理。round()函数的格式：round(x, d)， 其中x表示需要被处理的数据，d表示要返回的小数位数，即round(x, d)代表返回参数x的四舍五入的有 d 位小数的一个数字。d=0表示取整，d=1表示要返回一位小数，以此类推。此外，round()会自动四舍五入。
js代码-面试题---0.1 +0.2 为啥不精确等于0.3
07-16
最后，当结果转换回十进制时，你会看到它并不等于0.3，而是0.30000000000000004。 解决这个问题的方法有几种，其中一种是在进行比较时允许一定的误差范围，例如使用`Math.abs(a - b) < Number.EPSILON` 来判断两个...
为什么 0.1+0.2=0.30000000000000004
luoganttcc的博客
06-10 983
0.1 和 0.2 是如何表示的？ 根据前面的讲解，十进制 0.1 转为二进制小数，得到的是 0.0001100… （重复1100）这样一个循环二进制小数，使用 IEEE754 表示如下图：在浮点数的舍入问题上，IEEE 浮点格式定义了 4 种不同的舍入方式，如下表所示。其中，默认的舍入方法是向偶数舍入，而其他三种可用于计算上界和下界。同样的方法，0.2 用单精度浮点数表示是：0.20000000298023223876953125。所以，0.1 + 0.2 的结果是：0.30000000447034835
从0.1+0.2=0.30000000000000004再看JS中的Number类型
weixin_34346099的博客
01-30 154
写在前面 今天在看《JavaScript高级程序设计》的时候，注意到书中特意提到了0.1+0.2=0.30000000000000004这样一个浮点数计算错误的问题，觉得很有意思。平时在工作中对于浮点数了解地并不多，正好最近小组同学也遇到了这个问题，准备来总结下这个看似简单的Number基础类型，其实并不简单。这篇博客意在从这个奇怪的计算结果去学习总结浮点数的相关知识。 两个既定的事实 在JS中...
为什么 0.1 + 0.2 = 0.300000004？
qq_44241861的博客
10-15 1515
文章目录一、 二进制无法在有限的长度中精确地表示十进制中 0.1 和 0.2；单精度浮点数、双精度浮点数的位数决定了它们能够表示的精度上限 为什么 0.1 + 0.2 = 0.300000004？ 答：使用二进制表达十进制的小数时，某些数字无法被有限位的二进制小数表示，0.1与0.2 在二进制中的表示是无限位的； 十进制的小数可以转换为浮点数的二进制，而单精度和双精度的浮点数只包括 7 位或者 15 位的有效小数位，有限的浮点数位数无法精确表示无限的二进制小数，存储需要无限位表示的小数时只能存储近似值 详解
为什么 0.1 + 0.2 = 0.300000004
HollisChuang's Blog
04-13 1822
JavaScript 作为一门诞生自上个世纪 90 年代的编程语言[^1]，从诞生之初就因为诡异的隐式类型转换等原因被黑，很多 JavaScript 的开发者还会吐槽浮点数加法的『奇葩...
为什么“0.1+0.2=0.30000000000000004”？
xjanting的博客
03-28 2276
首先声明这不是bug，原因在与十进制到二进制的转换导致的精度问题！其次这几乎出现在很多的编程语言中：C/C++,Java,Javascript中，准确的说：“使用了IEEE 754浮点数格式”来存储浮点类型(float 32,double 64)的任何编程语言都有这个问题！简要介绍下IEEE 754浮点格式：它用科学记数法以底数为2的小数来表示浮点数。IEEE浮点数（共32位）用1位表示数字符号，
皕杰报表中0.1+0.2为什么等于0.30000000000000004而不是0.3？
bjbb_2007的博客
06-24 160
经常有人问，我用皕杰报表计算时，总是得不到想要的结果。那是你没搞明白计算机是通过二进制来计算的，在把十进制小数转化为二进制时有时会是一串无限循环的二进制数，计算机是无法表达无限循环的二进制数的，毕竟计算机的资源是有限。 因此，计算机只能用「近似值」来表示该二进制，那么意味着计算机存放的小数可能不是一个真实值，现在基本都是用 IEEE 754 规范的单精度浮点类型或双精度浮点类型来存储小数的，根据精度的不同，近似值也会不同。 所以，你会看到在计算机中 0.1 + 0.2 并不等于完整的 0....
为什么0.1+0.2=0.30000000000000004？怎么解决这个问题？
weixin_46305401的博客
02-05 1258
为什么0.1+0.2=0.30000000000000004？怎么解决这个问题？     在我们平时写代码的时候，可能会出现和我们的认知不符的情况。比如在我们的认知里0.1+0.2=0.3，但代码运行的结果却是0.30000000000000004。float类型和double类型的数在运算时有可能会有误差，也有可能不会出现误差。代码示例如下： public class Demo { public static void main(String[] args) { double a=
x = np.arange(-7, 7, 0.01)
最新发布
03-08
<think>好的，用户让我介绍一下这行代码：x = np.arange(-7, 7, 0.01)。首先，我得确认用户对numpy的了解程度。可能他们刚开始学Python，或者对numpy的函数不太熟悉。 首先，np.arange是numpy里的一个常用函数，用来生成等差数列。参数是起始点、终止点、步长。那这行代码的具体作用呢？起始-7，终止7，步长0.01。生成的数组应该从-7开始，每次加0.01，直到接近7但不包括7。 接下来需要解释每个参数的意义。用户可能想知道为什么终止点是7而不是包含进去，这时候要说明arange函数是左闭右开的。比如，当步长是1的时候，np.arange(0,3)会生成0,1,2，所以同样的道理，这里到7的时候就不会包含进去。 然后，生成的数据点数量是多少呢？计算的话，总长度是14（从-7到7的距离），步长0.01，所以大概有14 / 0.01 = 1400个点，但实际可能因为浮点数精度问题稍微有点差异，但大致是1400个点左右。这点可能需要提到，但用户可能更关心应用场景。 用户可能的应用场景是什么？通常这种密集的点用来画函数图像，比如在matplotlib里画sin、cos或者其他连续函数的图形。比如，用户可能在做数据可视化，或者需要生成一个平滑曲线时需要密集的点。 另外，步长0.01意味着高分辨率，这样画出来的图更平滑。如果步长太大，比如0.1，图像可能会有锯齿感。这里0.01的选择可能是为了平衡精度和计算资源，毕竟太多点会占用内存，但现在的计算机处理1400个点应该没问题。 还要注意，numpy的arange和Python内置的range函数不同，arange可以处理浮点数步长，而range只能处理整数。这时候可能需要比较两者的区别，帮助用户理解为什么用numpy而不是原生的方法。 可能用户会遇到的问题包括：生成的数组是否正确，是否包含终点，步长是否合适。比如，如果用户想要包括7的话，可能需要调整终止点或者使用其他函数如linspace，这时候可以提到np.linspace( -7, 7, 1401 )会更精确地包括终点，因为可以指定点的数量。 此外，生成的x数组类型是numpy的ndarray，用户可能需要了解后续如何处理这个数组，比如进行数学运算、绘图等。比如，他们可能会用x来计算y = np.sin(x)，然后用matplotlib画图。 最后，是否需要给出一个示例？比如展示如何用这个x数组生成一个sin曲线，并绘图。这样用户能更直观地理解这行代码的用途。不过用户的问题只是介绍这行代码，可能不需要深入，但举例子总是有帮助的。 总结下来，回答的结构应该包括函数的作用、参数解释、生成的数据特点、应用场景、可能的注意事项或替代方案，以及示例用法。这样用户能全面了解这行代码的意义和用法。</think>以下是对代码`x = np.arange(-7, 7, 0.01)`的详细介绍： ### 功能说明 使用NumPy库生成一个**等间隔数值序列**，范围从-7到7（不包含7），步长为0.01。这是科学计算中常用的**坐标点生成方法**，特别适合用于函数绘图、信号处理等场景。 --- ### 参数解析 ```python np.arange(start, stop, step) ``` | 参数 | 值 | 说明 | |-------|------|-------------------------| | start | -7 | 起始值（包含） | | stop | 7 | 终止值（不包含） | | step | 0.01 | 步长（相邻两数的间隔） | --- ### 生成数据特点 1. **元素总数**：$\frac{7 - (-7)}{0.01} = 1400$个（实际输出1400个浮点数） 2. **首尾元素**： ```python x[0] = -7.0 # 第一个元素 x[-1] = 6.99 # 最后一个元素（7 - 0.01） ``` 3. **数据类型**：`numpy.ndarray`（NumPy数组） --- ### 数学表达式 生成的数组等价于： $$ x = \{-7.00,\ -6.99,\ -6.98,\ ...,\ 6.98,\ 6.99\} $$ --- ### 典型应用场景 1. **函数绘图**（需配合matplotlib）： ```python import matplotlib.pyplot as plt y = np.sin(x) # 计算正弦函数值 plt.plot(x, y) # 绘制平滑曲线 ``` ![正弦函数图](https://example.com/sine-wave.png) 2. **数值模拟** ```python # 高斯分布计算 sigma = 1.0 gaussian = 1/(sigma*np.sqrt(2*np.pi)) * np.exp(-x**2/(2*sigma**2)) ``` 3. **信号处理** ```python # 生成时域信号 t = x # 时间轴 frequency = 2 # 2Hz signal = np.sin(2 * np.pi * frequency * t) ``` --- ### 扩展知识 1. **与`np.linspace`的区别**： - `arange`：通过步长控制生成元素 - `linspace`：通过指定元素数量自动计算步长 ```python # 等效写法（包含终点） x_lin = np.linspace(-7, 7, 1401) # 1401个点 ``` 2. **精度问题**： ```python # 浮点数运算可能导致的误差示例 >>> 0.1 + 0.2 == 0.3 False # 实际值为0.30000000000000004 ``` 因此实际生成的数组末尾可能略微偏离理论值 --- ### 实际输出示例 ```python import numpy as np x = np.arange(-7, 7, 0.01) print(x.shape) # 输出：(1400,) print(x[:3]) # 输出：[-7. -6.99 -6.98] print(x[-3:]) # 输出：[6.97 6.98 6.99] ```
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值