python基本数据类型--浮点型(float)

爆笑蛙

已于 2023-06-18 18:47:13 修改

阅读量2.3w

点赞数 15

分类专栏：小白轻松学python 文章标签： python 开发语言

于 2023-05-30 21:02:33 首次发布

本文链接：https://blog.csdn.net/qq_40148262/article/details/130795732

版权

小白轻松学python 专栏收录该内容

24 篇文章 34 订阅

订阅专栏

浮点型(float)的定义

就是数学中的小数如：1.1，-1.1，0.123，-0.456等等，属于不可迭代对象。浮点型是不可变的数据类型，在内存中每个浮点型数据只存在唯一的地址。在代码中我们可以使用以下两种方式来表示浮点型数据。

第一种

number = 1.6

给变量number赋值为1.6，此时number的数据类型为浮点型，number的值为1.6。

第二种

number = float(1.6)

给变量number赋值为1.6，此时number的数据类型为浮点型，number的值为1.6。跟整型一样这两种方式在python解释器看来都是一样的，因为第一种写法更简单，所以我们常用第一种写法。但是第二种方式还有一个特殊的作用，就是可以把整型转换成浮点型，这是第一种方式做不到的。如下：

number = float(1)  # 把整数1转换为小数1.0，再赋值给变量number
print(number)  # 1.0

给变量number赋值为1.0，此时number的数据类型为浮点型，number的值为1.0。这种方式会在整数后保留一位小数位，并且小数位为0。此时number是一个小数1.0，但它和整数1的大小是一样的。

科学计数法

小数的缩写，科学计数法。在python中可以把一些很长的小数，用科学计数法的方式缩写。如下：

a = 0.0000000000003
print(a)  # 3e-13

我们执行上面两行代码，打印出a的值为3e-13。其中e表示10的指数函数，e-13就表示10的-13次方，3e-13就表示 $3\times10^{-13}$ 。python中使用科学计数法表示的数据都属于浮点型，如下：

a = 1e2
print(a)  # 100.0

我们执行上面两行代码，打印出a的值为100.0。在我们看来1e2应该是 $1\times 10^{2}= 100$ ，但是在python中它表示的是一个小数100.0。

为什么0.1加0.2不等于0.3？

这个知识点，初学者不需要深究。能看懂最好，看不懂也没关系，可以慢慢来。我们去执行下面这段代码

a = 0.1 + 0.2
print(a)  # 0.30000000000000004

我们从执行的结果中可以发现打印出a的值为0.30000000000000004，这个值跟我们预想的值0.3有一些区别。为什么python在处理小数之间的计算时，会出现这种计算得不准确的情况。其实这和python没什么关系，可以说任何的编程语言都会遇到这种情况。这和计算机CPU的计算逻辑有关，因为绝大多数CPU只能处理2进制数据，CPU中的全加逻辑电路是根据处理2进制数来设计的。当然我们也可以设计出处理10进制数的全加逻辑电路，但这种电路需要更大的空间和消耗更多的资源，所以我们会采用更简单的电路。毕竟2进制跟电路跟相配。

现在我们知道了CPU只会做2进制的算数，在处理10进制数时，需要先把10进制数转换为2进制数。所有的10进制整数都能完美的转换为2进制数，但10进制的小数就不一定能完美的转换为2进制的小数了。例如10进制的0.1，我们来手动转换一下，看能不能完美的转换为2进制小数。我们这里采用乘以2的方式来转换，我们第一次计算把0.1✖2，判断结果是否大于1，如果结果小于1，2进制的第一位小数为0，如果结果大于1，把个位的1减掉并且2进制的第一位小数为1。我们第二次计算把第一次计算的结果✖2，判断结果是否大于1，如果结果小于1，2进制的第二位小数为0，如果结果大于1，把个位的1减掉并且2进制的第二位小数为1...以此类推直到10进制数为0。推导结果如下：

第1次  0.1 * 2 = 0.2 小于1 2进制小数为0.0
第2次  0.2 * 2 = 0.4 小于1 2进制小数为0.00
第3次  0.4 * 2 = 0.8 小于1 2进制小数为0.000
第4次  0.8 * 2 = 1.6 大于1 2进制小数为0.0001 这里需要把1.6 - 1 = 0.6
第5次  0.6 * 2 = 1.2 大于1 2进制小数为0.00011 这里需要把1.2 - 1 = 0.2
第6次  0.2 * 2 = 0.4 小于1 2进制小数为0.000110
第7次  0.4 * 2 = 0.8 小于1 2进制小数为0.0001100
第8次  0.8 * 2 = 1.6 大于1 2进制小数为0.00011001 这里需要把1.6 - 1 = 0.6
第9次  0.6 * 2 = 1.2 大于1 2进制小数为0.000110011 这里需要把1.2 - 1 = 0.2
第10次 0.2 * 2 = 0.4 小于1 2进制小数为0.0001100110
.....
.....
无限循环，算不完

从上面的推导中，不知道大家有没有看出来，从第6次计算就已经开始循环了。所以10进制的0.1用2进制数不能完美的表示出来，只能用近似值来表示。由于CPU在计算0.1加0.2时，使用的是近似值，所以计算出来的结果就会和理论值存在误差。我们怎样消除这个误差呢？

第一种方法，使用round函数来截取小数。round函数需要传入两个参数，第一个参数为需要处理的数据，第二个参数为要保留的小数位数。如下：

a = 0.1 + 0.2  # a = 0.30000000000000004
b = round(a, 1)  # 用round函数处理变量a的值，使a的值只保留一位小数，再把处理后的数据赋值给变量b
print(b)  # 0.3

第二种方法，把0.1和0.2分别乘以10变为1和2，再用1加2得到3，再用3除以10得到0.3。我推荐使用这种方式，需要注意的是加减和乘除在最后除以10的时候有区别。如果是计算0.1乘以0.2，把0.1和0.2分别乘以10变为1和2，再用1乘以2得到2，再用2除以100得到0.02。

浮点型算术运算符

整型和浮点型是可以通过算术运算符相互运算的，整型和浮点型相互运算的结果一定是浮点型数据。

+	加号，可以做加法
-	减号，可以做减法
*	乘号，可以做乘法
/	除号，可以做除法
%	取余，做整除，能整除时返回0.0，不能整除时返回余数
//	取整，做整除，只返回商，不返回余数
**	求幂，做幂运算（次方）

算术运算符（+）

就是做数学中的加法运算，把两个数相加求和。举个例子，请看如下代码：

number_a = 3.3
number_b = 2.5
number_c = number_a + number_b
print(number_c)  # 5.8

浮点型number_a和number_b相加求和，再把结果赋值给number_c，所以number_c的值为5.8。

算术运算符（-）

就是做数学中的减法运算，把两个数相减求差。举个例子，请看如下代码：

number_a = 3.5
number_b = 3
number_c = number_a - number_b
print(number_c)  # 0.5

浮点型number_a和整型number_b相减求差，再把结果赋值给number_c，所以number_c的值为0.5。

算术运算符（*）

就是做数学中的乘法运算，把两个数相乘求积。举个例子，请看如下代码：

number_a = 3.5
number_b = 2
number_c = number_a * number_b
print(number_c)  # 7.0

浮点型number_a和整型number_b相乘求积，再把结果赋值给number_c，所以number_c的值为7.0。

算术运算符（/）

就是做数学中的除法运算，把两个数相除求商。举个例子，请看如下代码：

number_a = 3.5
number_b = 2.5
number_c = number_a / number_b
print(number_c)  # 1.4

浮点型number_a和number_b相除求商，再把结果赋值给number_c，所以number_c的值为1.4。

算术运算符（%）

就是做数学中的取余运算，把两个数相整除，当不能整除时会有余数，就返回这个余数；当可以整除时，余数为0，就返回0。举个例子，请看如下代码：

number_a = 7.5
number_b = 2
number_c = number_a % number_b
print(number_c)  # 1.5

7.5整除2得3.0余1.5，返回余数1.5，把余数1.5赋值给number_c，所以number_c的值为1.5。

number_a = 7.5
number_b = 2.5
number_c = number_a % number_b
print(number_c)  # 0.0

7.5是可以整除2.5的，但整除时也可以说余数为0.0。7.5整除2.5得3.0余0.0，返回余数0.0，把余数0.0赋值给number_c，所以number_c的值为0.0。

算术运算符（//）

就是做数学中的整除，把两个数相整除求商。只返回商，不返回余数。举个例子，请看如下代码：

number_a = 7.5
number_b = 3.5
number_c = number_a // number_b
print(number_c)  # 2.0

7.5整除3.5得2.0余0.5，返回商2.0，把商2.0赋值给number_c，所以number_c的值为2.0。

算术运算符（**）

就是做数学中的幂运算，求x的n次方。举个例子，请看如下代码：

number_a = 5.5
number_b = 2
number_c = number_a ** number_b
print(number_c)  # 30.25

求number_a的number_b次方，number_a的值为5.5，number_b的值为2。所以就是5.5的2次方等于30.25，所以number_c的值为30.25。

浮点型比较运算符

整型和浮点型是可以通过比较运算符相互比较大小的。

==	等于，判断左右两边是否相等
!=	不等于，判断左右两边是否不相等
>	大于，判断左边是否大于右边
<	小于，判断左边是否小于右边
>=	大于等于，判断左边是否大于或等于右边
<=	小于等于，判断左边是否小于或等于右边

比较运算符（==）

用于判断左右两边的值是否相等，如果相等返回真（True），如果不相等则返回假（False）。True和False是python中的bool值，True表示真False表示假，bool值也属于python的基本数据类型。我们这里可以这样去理解，当条件成立时为True，条件不成立时为False。举个例子，请看下面的代码：

number_a = 2.5
number_b = 2.5
print(number_a == number_b)  # True

判断number_a是否等于number_b，number_a的值为2.5，number_b的值也为2.5，所以number_a和number_b是相等的，条件成立返回True。

number_a = 2.5
number_b = 3
print(number_a == number_b)  # False

number_a的值为2.5，number_b的值为3，所以number_a和number_b是不相等的，条件不成立返回False。

比较运算符（!=）

用于判断左右两边的值是否不相等，如果不相等时返回True，如果相等时返回False。举个例子，请看下面的代码：

number_a = 2.0
number_b = 2
print(number_a != number_b)  # False

判断number_a是否不等于number_b，number_a的值为2.0，number_b的值为2，所以number_a和number_b是相等的，条件不成立返回False。

number_a = 2.5
number_b = 3.0
print(number_a != number_b)  # True

number_a的值为2.5，number_b的值为3.0，所以number_a和number_b是不相等的，条件成立返回True。

比较运算符（>）

用于判断左边是否大于右边，如果大于返回True，如果不大于时（小于或等于时）返回False。举个例子，请看下面的代码：

number_a = 2.1
number_b = 3
print(number_a > number_b)  # False

判断number_a是否大于number_b，number_a的值为2.1，number_b的值为3，所以number_a是小于number_b的，条件不成立返回False。

number_a = 2.2
number_b = 2.2
print(number_a > number_b)  # False

number_a的值为2.2，number_b的值也为2.2，所以number_a是等于number_b的，条件不成立返回False。

number_a = 2
number_b = 1.6
print(number_a > number_b)  # True

number_a的值为2，number_b的值为1.6，所以number_a是大于number_b的，条件成立返回True。

比较运算符（<）

用于判断左边是否小于右边，如果小于返回True，如果不小于时（大于或等于时）返回False。举个例子，请看下面的代码：

number_a = 3.3
number_b = 2.0
print(number_a < number_b)  # False

判断number_a是否小于number_b，number_a的值为3.3，number_b的值为2.0，所以number_a是大于number_b的，条件不成立返回False。

number_a = 2
number_b = 2.0
print(number_a < number_b)  # False

number_a的值为2，number_b的值为2.0，所以number_a是等于number_b的，条件不成立返回False。

number_a = 1.8
number_b = 2.6
print(number_a < number_b)  # True

number_a的值为1.8，number_b的值为2.6，所以number_a是小于number_b的，条件成立返回True。

比较运算符（>=）

用于判断左边是否大于或等于右边，如果大于等于返回True，如果不大于等于时（小于时）返回False。举个例子，请看下面的代码：

number_a = 3.7
number_b = 2.1
print(number_a >= number_b)  # True

判断number_a是否大于或等于number_b，number_a的值为3.7，number_b的值为2.1，所以number_a是大于number_b的，条件成立返回True。

number_a = 2.8
number_b = 2.8
print(number_a >= number_b)  # True

number_a的值为2.8，number_b的值也为2.8，所以number_a是等于number_b的，条件成立返回True。

number_a = 1.3
number_b = 2.0
print(number_a >= number_b)  # False

number_a的值为1.3，number_b的值为2.0，所以number_a是小于number_b的，条件不成立返回False。

比较运算符（<=）

用于判断左边是否小于或等于右边，如果小于等于返回True，如果不小于等于时（大于时）返回False。举个例子，请看下面的代码：

number_a = 3.3
number_b = 2.7
print(number_a <= number_b)  # False

判断number_a是否小于或等于number_b，number_a的值为3.3，number_b的值为2.7，所以number_a是大于number_b的，条件不成立返回False。

number_a = 2.6
number_b = 2.6
print(number_a <= number_b)  # True

number_a的值为2.6，number_b的值也为2.6，所以number_a是等于number_b的，条件成立返回True。

number_a = 1.3
number_b = 2.5
print(number_a <= number_b)  # True

number_a的值为1.3，number_b的值为2.5，所以number_a是小于number_b的，条件成立返回True。

浮点型赋值运算符

整型和浮点型是可以通过赋值运算符相互运算的，整型和浮点型相互运算的结果一定是浮点型数据。

=	赋值运算符（前面就已经用到了，给某个变量赋值）
+=	加法赋值运算符，加等于
-=	减法赋值运算符，减等于
*=	乘法赋值运算符，乘等于
/=	除法赋值运算符，除等于
%=	取余赋值运算符，求余等于
//=	取整赋值运算符，求模等于
**=	求幂赋值运算符，求幂等于

赋值运算符（=）

用于给变量赋值，也可以说给数据取名字，方便操作数据，这里的数据包括python中的任意对象。举个例子，请看下面的代码：

number_a = 1
number_b = 2.5
number_c = number_a + number_b
print(number_c)  # 3.5

把整型数据1赋值给变量number_a，number_a的值为1。把浮点型数据2.5赋值给变量number_b，number_b的值为2.5。number_a和number_b进行加法运算，把求和结果浮点型数据3.5赋值给变量number_c。

赋值运算符（+=）

加法赋值运算符，顾名思义先做加法再赋值。+=作用的对象必须是一个已经定义过的变量，就是这个变量必须已经赋值了。如果我们直接作用于一个未定义的变量会报错，比如下面的代码：

number += 1.5

执行结果如下：

报错显示变量number未定义。所以我们要对一个变量使用+=，必须先给这个变量赋值。请看下面的代码：

number = 2.5
number += 3.5  # number = number + 3.5
print(number)  # 6.0

第一行代码number = 2.5，给变量number赋值为2.5，number定义为浮点型数据值为2.5。第二行代码number += 3.5，相当于number = number + 3.5。先执行number + 3.5，相加求和结果为6.0，再把结果6.0赋值给number，这时number的值就变成6.0了。有的同学可能不太理解number = number + 3.5这种写法，我们可以把它想象成下面这种写法：

number = 2.5
number_s = number + 3.5
number = number_s
print(number)  # 6.0

多用一个变量number_s来接收number + 3.5的值，这时number_s的值为6.0。再把number_s的值赋给number，就是重新给number赋值，number的值就由原来的2.5变为现在的6.0了。number = number + 3.5就是把number_s给省略了，这样就比较好理解了。为什么可以省略，因为CPU中的寄存器可以临时存储数据，替代了用变量存储数据的行为，并且CPU从寄存器中存取数据比从内存中存取数据快很多倍。

赋值运算符（-=）

减法赋值运算符，顾名思义先做减法再赋值。-=作用的对象也必须是一个已经定义过的变量，举个例子，请看下面的代码：

number = 2.5
number -= 3.5  # number = number -3.5
print(number)  # -1.0

第一行代码number = 2.5，给变量number赋值为2.5，number定义为浮点型数据值为2.5。第二行代码number -= 3.5，相当于number = number - 3.5。先执行number - 3.5，相减求差结果为-1.0，再把结果-1赋值给number，这时number的值就变成-1了。理解方式参考+=。

赋值运算符（*=）

乘法赋值运算符，顾名思义先做乘法再赋值。*=作用的对象也必须是一个已经定义过的变量，举个例子，请看下面的代码：

number = 2.5
number *= 3  # number = number * 3
print(number)  # 7.5

第一行代码number = 2.5，给变量number赋值为2.5，number定义为浮点型数据值为2.5。第二行代码number *= 3，相当于number = number * 3。先执行number * 3，相乘求积结果为7.5，再把结果7.5赋值给number，这时number的值就变成7.5了。理解方式参考+=。

赋值运算符（/=）

除法赋值运算符，顾名思义先做除法再赋值。/=作用的对象也必须是一个已经定义过的变量，举个例子，请看下面的代码：

number = 7.5
number /= 2.5  # number = number / 2.5
print(number)  # 3.0

第一行代码number = 7.5，给变量number赋值为7.5，number定义为浮点型数据值为7.5。第二行代码number /= 2.5，相当于number = number / 2.5。先执行number / 2.5，相除求商结果为3.0，再把结果3.0赋值给number，这时number的值就变成3.0了。理解方式参考+=。

赋值运算符（%=）

取余赋值运算符，顾名思义先做整除取余再赋值。%=作用的对象也必须是一个已经定义过的变量，举个例子，请看下面的代码：

number = 7.5
number %= 3  # number = number % 3
print(number)  # 1.5

第一行代码number = 7.5，给变量number赋值为7.5，number定义为浮点型数据值为7.5。第二行代码number %= 3，相当于number = number % 3。先执行number % 3，整除取余结果为1.5，再把结果1.5赋值给number，这时number的值就变成1.5了。理解方式参考+=。

赋值运算符（//=）

取整赋值运算符，顾名思义先做整除取整再赋值。//=作用的对象也必须是一个已经定义过的变量，举个例子，请看下面的代码：

number = 7.5
number //= 3.1  # number = number // 3.1
print(number)  # 2.0

第一行代码number = 7.5，给变量number赋值为7.5，number定义为浮点型数据值为7.5。第二行代码number //= 3.1，相当于number = number // 3.1。先执行number // 3.1，整除取整结果为2.0，再把结果2.0赋值给number，这时number的值就变成2.0了。理解方式参考+=。

赋值运算符（**=）

求幂赋值运算符，顾名思义先做幂运算再赋值。**=作用的对象也必须是一个已经定义过的变量，举个例子，请看下面的代码：

number = 7.5
number **= 3  # number = number ** 3
print(number)  # 421.875

第一行代码number = 7.5，给变量number赋值为7.5，number定义为浮点型数据值为7.5。第二行代码number **= 3，相当于number = number ** 3。先执行number ** 3，做幂运算结果为421.875，再把结果421.875赋值给number，这时number的值就变成421.875了。理解方式参考+=。

浮点型身份运算符

浮点型数据其实不太需要身份运算符来判断两个整型数据的内存地址是否一致。因为浮点型数据具有不可变的特性，这就导致了只要两个浮点型数据的值相等，它们的内存地址就是一样的。所以我们完全可以使用==和!=来代替身份运算符在浮点型中的作用，但我们不要把==和!=与身份运算符搞混了。==和!=判断的是值是否相等，而身份运算符判断的是内存地址是否相同。对于可变的数据类型来说，即使它们的值相等，它们的内存地址也是不同的。

is	判断左右两边的内存地址是否相同，相同返回True，否则返回False
is not	判断左右两边的内存地址是否相同，不同返回True，否则返回False

身份运算符（is）

is用于判断左右两个对象的内存地址是否相同，如果相同返回True，不同返回False。举个例子，请看下面的代码：

a = 1.5
b = 1.5
print(id(a))  # 内存地址：1641575181264
print(id(b))  # 内存地址：1641575181264
print(a is b)  # True

a和b都是浮点型1.5，因为浮点型是不可变的数据类型，所以两个相同的浮点型数据一定取自同一个地方。我们可以使用id函数来查看python中任意对象的内存地址，使用id函数后我们发现a和b的内存地址确实是相同的。a和b所代表的浮点型数据1.5取自内存中的同一个地方，所以a is b返回True。

a = 1.5
b = 2.5
print(id(a))  # 内存地址：1415926344656
print(id(b))  # 内存地址：1415921505360
print(a is b)  # False

a是浮点型1.5，b是浮点型2.5。因为浮点型数据1.5和2.5存放在内存中不同的地方，所以a is b返回False。

身份运算符（is not）

is not用于判断左右两个对象的内存地址是否不同，如果不同返回True，相同返回False。举个例子，请看下面的代码：

a = 1.5
b = 2.5
print(id(a))  # 内存地址：1415926344656
print(id(b))  # 内存地址：1415921505360
print(a is not b)  # True

a是浮点型1.5，b是浮点型2.5。因为浮点型数据1.5和2.5存放在内存中不同的地方，所以a is not b返回True。

a = 1.5
b = 1.5
print(id(a))  # 内存地址：2191498046416
print(id(b))  # 内存地址：2191498046416
print(a is not b)  # False

a和b都是浮点型1.5，a和b所代表的浮点型数据1.5取自内存中的同一个地方，所以a is not b返回False。

需要注意的是类似整型2和浮点型2.0这种数据，它们的大小是一样的，使用==来判断时它们是相等的。但是它们分别属于两种数据类型，所以它们的内存地址是不一样的。请看如下代码：

a = 2
b = 2.0
print(id(a))  # 内存地址：140733443872560
print(id(b))  # 内存地址：2023885401040
print(a == b)  # True
print(a is b)  # False

爆笑蛙

关注

15
点赞
踩
70

收藏

觉得还不错? 一键收藏
1
评论
python基本数据类型--浮点型(float)

就是数学中的小数如：1.1，-1.1，0.123，-0.456等等，属于不可迭代对象。浮点型是不可变的数据类型，在内存中每个浮点型数据只存在唯一的地址。浮点型数据也常被用于计算，所以我们需要知道浮点型可以使用的运算符。浮点型可以使用的运算符有：算数运算符、比较运算符、赋值运算符和身份运算符。
复制链接

扫一扫