精华内容
下载资源
问答
  • 在深入了解浮点数的实现之前,先来看几个 Python 浮点数计算有意思的例子:0.1 == 0.10000000000000000000001IEEE 浮点数表示法这些看起来违反常识的“错误”并非 Python 的错,而是由浮点数的规则所决定的,即使放...

    浮点数用来存储计算机中的小数,与现实世界中的十进制小数不同的是,浮点数通过二进制的形式来表示一个小数。在深入了解浮点数的实现之前,先来看几个 Python 浮点数计算有意思的例子:

    0.1 == 0.10000000000000000000001

    IEEE 浮点数表示法

    这些看起来违反常识的“错误”并非 Python 的错,而是由浮点数的规则所决定的,即使放到其它语言中结果也是这样的。要理解计算机中浮点数的表示规则,先来看现实世界中十进制小数是如何表示的:

    1.234 = 1 + 1/10 + 2/100 + 3/1000

    可以用下面的公式来表示:

    tex_df1fd2d2a15a2d293bf23be9be0094e9.gif

    其中

    tex_d247f594c78d0d2be10fc6d82512cc4e.gif 是十进制中 0~9 的数字。而如果是一个二进制的小数:

    1.001 = 1 + 0/2 + 0/4 + 1/8

    可以用下面的公式来表示:

    tex_4e8a49b20452b31ea1aab09f57fc7f7d.gif

    其中

    tex_d247f594c78d0d2be10fc6d82512cc4e.gif 是二进制中的 0 或 1。Python 中的浮点数都是双精度的,也就说采用 64 位来表示一个小数,那这 64 位分别有多少用来表示整数部分和小数部分呢?根据 IEEE 标准,考虑到符号位,双精度表示法是这样分配的:

    tex_221d3e930326f53116674557aa8b8aff.gif

    也就是说用1位表示符号位,11位表示整数部分,52位表示小数部分。正如十进制中我们无法精确表示某些分数(如10/3),浮点数中通过 d1/2 + d2/4 + ... 的方式也会出现这种情况,比如上面的例子中,十进制中简单的 0.1 就无法在二进制中精确描述,而只能通过近似表示法表示出来:

    (3602879701896397, 36028797018963968)

    也就是说 0.1 是通过 3602879701896397/36028797018963968 来近似表示的,很明显这样近似的表示会导致许多差距很小的数字公用相同的近似表示数,例如:

    (0.10000000000000001).as_integer_ratio()

    (3602879701896397, 36028797018963968)

    在 Python 中所有这些可以用相同的近似数表示的数字统一采用最短有效数字来表示:

    print(0.10000000000000001)

    浮点数运算

    既然有些浮点数是通过近似值表示的,那么在计算过程中就很容易出现误差,就像最开始的第二个例子一样:

    a = .1 + .1 + .1

    b = .3

    print(a.as_integer_ratio())

    print(b.as_integer_ratio())

    print(a == b)

    (1351079888211149, 4503599627370496)

    (5404319552844595, 18014398509481984)

    False

    为了解决运算中的问题,IEEE 标准还指定了一个舍入规则(round),即 Python 中内置的 round 方法,我们可以通过舍入的方式取得两个数的近似值,来判断其近似值是否相等:

    round(a, 10) == round(b, 10)

    当然这种舍入的方式并不一定是可靠的,依赖于舍入的选择的位数,位数太大,就失去了 round 的作用,太小,就会引入别的错误:

    print(round(a, 17) == round(b, 17))

    print(round(0.1, 1) == round(0.111, 1))

    Python 中使用更精确的浮点数可以通过 decimal 和 fractions 两个模块,从名字上也能猜到,decimal 表示完整的小数,而 fractions 通过分数的形式表示小数:

    from decimal import Decimal

    a = Decimal(0.1)

    b = Decimal(0.1000000000000001)

    c = Decimal(0.10000000000000001)

    print(a)

    print(b)

    print(c)

    a == b == c

    0.1000000000000000055511151231257827021181583404541015625

    0.10000000000000010269562977782697998918592929840087890625

    0.1000000000000000055511151231257827021181583404541015625

    False

    from fractions import Fraction

    f1 = Fraction(1, 10) # 0.1

    print(float(f1))

    f3 = Fraction(3, 10) # 0.3

    print(float(f3))

    print(f1 + f1 + f1 == f3)

    总结

    浮点数这些奇特的特性让我们不得不在使用的时候格外注意,尤其是当有一定的精度要求的情况下。如果真的是对精度要求较高且需要频繁使用浮点数,建议使用更专业的 SciPy 科学计算包。

    打赏支持我写出更多好文章,谢谢!

    打赏作者

    打赏支持我写出更多好文章,谢谢!

    58883_0.jpg

    展开全文
  • python浮点数处理过程中,我们常常发现明明使用round方法设置了所需保留的小数点个数,结果却往往不尽人意,今天我们就来介绍一下如何实现python浮点数的高精度表示。 一、常见的问题 浮点数运算输出17位长度...

    文章目录

     


    前言

    在python浮点数处理过程中,我们常常发现明明使用round方法设置了所需保留的小数点个数,结果却往往不尽人意,今天我们就来介绍一下如何实现python浮点数的高精度表示。

     

    一、常见的问题

    浮点数运算输出17位长度的结果,但只有15个数字是准确的,也就是说python对于浮点数的运算具有摆尾性。如:下图运算。

    >>>3.141592653*1.234567898
    3.8785094379864535

    二、解决方案

    1.整数运算

    python对于整数的运算是完全准确的,也就是说我们可以先把小数点去除进行运算,之后再对所得结果做统一的处理。

    >>>3141592653*1234567898
    3878509437986453394

     

    2.decimal库

    decimal库是python的标准库,无需下载便可直接引用,首先开头通过import decimal引入decimal库。

    >>>import decimal
    >>>a=decimal.Decimal('3.141592653')
    >>>b=decimal.Decimal('1.234567898')
    >>>a*b
    Decimal('3.878509437986453394')

     


    总结

    可以看出通过decimal库的计算和整数计算结果是完全一样的,但对于decimal库处理过的浮点数,并不适合后续操作,对于较小的程序或项目,可以尝试使用该方法,对于大型且对结果精度要求较高的项目,小编在这里建议你使用第一种化为整数的方式实现,最后再对结果进行统一的移位处理。

     

    展开全文
  • 现实生活中,我们经常说的一个半小时,其应该用 1.5 个小时来表示。所有浮点数自然存在于生活中,并且广泛存在生活中。所有的浮点数都是近似的。>>> 1.2 * 67.199999999999999>>> 1.2 * 6 == 7.2 # 它们居然不相等...

    浮点数简单来说就是实数,也叫小数,不同于整数,其带有小数部分。浮点数广泛用于统计和科学计算上。

    现实生活中,我们经常说的一个半小时,其应该用 1.5 个小时来表示。所有浮点数自然存在于生活中,并且广泛存在生活中。

    所有的浮点数都是近似的。

    >>> 1.2 * 6

    7.199999999999999

    >>> 1.2 * 6 == 7.2 # 它们居然不相等

    False

    所以比较两个浮点数是否相等需要用 abs(a-b)<1e-5 来判断。

    >>> a = 1.2 * 6

    >>> abs(a-7.2) < 1e-5

    True

    至于为何浮点数不同于整数,其值可以认为都是近似值呢?这与采用的进制有关。如在十进制中,三分之一(1/3)就是无法准确表示的,只能近似等于 0.333333。但是这个数在三进制中就可以准确表示为 0.1。同样的情况也发生在二进制中,如十进制中的 0.1 在二进制中就不能准确表示。

    下面以浮点数 10.5 为例介绍浮点数的表示法。浮点数一般分为两部分,整数部分和小数部分。整数部分的表示法和整数的二进制表示法相同,如 10 用二进制数表示就是 1010。

    10 = 8+2 = 23+21 = 0b1010

    小数部分每位的权重依次是 2−1、2−2、2−3、2−4,所以 0.5 就可以表示为 0.1。

    所以 10.5 用二进制数表示为 0b1010.1 = 0b1.0101*23。这就是标准的浮点数表示法,其包括数值部分 0b1.0101 和指数 3。数值部分大于或等于 1 而且小于 2。

    如果用十六进制表示就是:

    0b1.0101*23 =0x1.5*23

    但是我们也不需要每个数都这么来手工计算,Python 提供了函数 hex(),它是浮点数对象的成员函数。下面演示其用法。

    >>> 10.5.hex() # 得到其内部表示法

    '0x1.5000000000000p+3' # 数值部分是0x1.5,指数部分是3

    浮点数的基本运算

    本节继续介绍浮点数的基本运算,包括加减乘除和幂运算。

    1) 加减乘除运算(+-*/)

    和整数一样,浮点数也支持加减乘除等基本运算,运算符号也相同。

    >>> 1.2 + 1.3 # 加法运算

    2.5

    >>> 1.2 - 2.3 # 减法运算

    -1.0999999999999999 # 得到一个近似值

    >>> 1.2 * 2.0 # 乘法运算

    2.4

    >>> 1.2 / 2.0 # 除法运算

    0.6

    2) 幂运算(**)

    浮点数也支持幂运算,符号也是 **。但是负数不支持小数幂的运算。

    >>> 1.2 ** 2

    1.44

    >>> 1.2 ** 2.3

    1.5209567545525315

    >>> -1.2 ** 2 # 等效于-(1.2 ** 2)

    -1.44

    >>> (-1.2) ** 2 # 负数的平方为正数

    1.44

    >>> (-1.2) ** 2.1 # 负数不支持小数幂运算

    Traceback (most recent call last): # 抛出异常

    File "", line 1, in

    ValueError: negative number cannot be raised to a fractional power

    浮点数的其他运算

    1) 将浮点数转换成近似的两个整数的商——as_integer_ratio()

    这是一个浮点数的成员函数。其用法如下:

    >>> a = 0.1 # 操作数

    >>> a.as_integer_ratio()

    (3602879701896397, 36028797018963968)

    >>> 3602879701896397.0 / 36028797018963968 # 两者的值很接近了

    0.1

    2) 判断某个浮点数是否为整数——is_integer()

    这是浮点数对象自带的函数,判断某个浮点数是否为一个整数。其用法如下:

    >>> a = 12.0

    >>> a.is_integer()

    True

    >>> a = 12.0001

    >>> a.is_integer()

    False

    当然这也是一个近似值,如 1.0000000000000001 就被看做 1。下面演示了这种情况。

    >>> 1.0000000000000001.is_integer() # 判断是否可以当作整数使用

    True

    >>> 1.0000000000000001 == 1.0

    True

    展开全文
  • 计算机智能处理可数集合的运算,但是全体实数是不可数的,所以计算机只能用一些奇怪的方法来拟合他,于是就产生了浮点数。为什么说浮点数缺乏精确性?在开始本文之前,让我们先来谈谈浮点数为什么缺乏精确性的问题,...

    计算机智能处理可数集合的运算,但是全体实数是不可数的,所以计算机只能用一些奇怪的方法来拟合他,于是就产生了浮点数。

    为什么说浮点数缺乏精确性?

    在开始本文之前,让我们先来谈谈浮点数为什么缺乏精确性的问题,其实这不是Python的问题,而是实数的无限精度跟计算机的有限内存之间的矛盾。

    举个例子,假如说我只能使用整数(即只精确到个位,计算机内的浮点数也只有有限精度,以C语言中的双精度浮点数double为例,精度为52个二进制位),要表示任意实数(无限精度)的时候我就只能通过舍入(rounding)来近似表示。

    比如1.2我会表示成1,2.4表示成2,3.6表示成4.

    所以呢?

    在算1.2 - 1.2的时候,由于计算机表示的问题,我算的实际上是1 - 1,结果是0,碰巧蒙对了;

    在算1.2 + 1.2 - 2.4的时候,由于计算机表示的问题,我算的实际上是1 + 1 - 2,结果是0,再次蒙对了;

    但是在算1.2 + 1.2 + 1.2 - 3.6的时候,由于计算机表示的问题,我算的实际上是1 + 1 + 1 - 4,结果是-1,运气没那么好啦!

    这里的1.2, 2.4, 3.6就相当于你问题里的0.1, 0.2和0.3,1, 2, 4则是真正在计算机内部进行运算的数值,我说清楚了吗?

    其他请看IEEE 754浮点数标准,比如CSAPP第二章啥的(虽然估计你没兴趣看)。

    另:不仅仅是浮点数的在计算机内部的表示有误差,运算本身也可能会有误差。比如整数2可以在计算机内准确表示,但是要算根号2就有误差了;再比如两个浮点数相除,本来两个数都是精确表示的,但除的结果精度却超出了计算机内实数的表示范围,然后就有误差了。

    好了,下面话不多说了,开始本文的正文:

    起步

    浮点数的一个普遍的问题是它们不能精确的表示十进制数。

    >>> a = 4.2

    >>> b = 2.1

    >>> a + b

    6.300000000000001

    >>> (a + b) == 6.3

    False

    >>>

    这是由于底层 CPU 和IEEE 754标准通过自己的浮点单位去执行算术时的特征。看似有穷的小数,在计算机的二进制表示里却是无穷的。

    一般情况下,这一点点的小误差是允许存在的。如果不能容忍这种误差(比如金融领域),那么就要考虑用一些途径来解决这个问题了。

    Decimal

    使用这个模块不会出现任何小误差。

    >>> from decimal import Decimal

    >>> a = Decimal('4.2')

    >>> b = Decimal('2.1')

    >>> a + b

    Decimal('6.3')

    >>> print(a + b)

    6.3

    >>> (a + b) == Decimal('6.3')

    True

    尽管代码看起来比较奇怪,使用字符串来表示数字,但是 Decimal 支持所有常用的数学运算。decimal模块允许你控制计算的每一方面,包括数字位数和四舍五入。在这样做之前,需要创建一个临时上下文环境来改变这种设定:

    >>> from decimal import Decimal, localcontext

    >>> a = Decimal('1.3')

    >>> b = Decimal('1.7')

    >>> print(a / b)

    0.7647058823529411764705882353

    >>> with localcontext() as ctx:

    ... ctx.prec = 3

    ... print(a / b)

    ...

    0.765

    >>> with localcontext() as ctx:

    ... ctx.prec = 50

    ... print(a / b)

    ...

    0.76470588235294117647058823529411764705882352941176

    >>>

    由于 Decimal 的高精度数字自然也就用字符串来做展示和中转。

    总结

    总的来说,当涉及金融领域时,哪怕是一点小小的误差在计算过程中都是不允许的。因此 decimal 模块为解决这类问题提供了方法。

    展开全文
  • 问题 昨天遇到一个问题,在 6.6045 保留三位小数时,使用 round() 函数进行计算,我们希望得到 6... 本文标题: Python浮点数四舍五入问题的分析与解决方法 本文地址: http://www.cppcns.com/jiaoben/python/287393.html
  • 解决方案浮点数的一个普遍问题是它们并不能精确的表示十进制数。 并且,即使是最简单的数学运算也会产生小的误差,比如:>>> a = 4.2>>> b = 2.1>>> a + b6.300000000000001>>> (a + b) == 6.3False>>>这些错误是由...
  • import numpy as np for i in np.arange(a,b,0.5):
  • python如何比较两个浮点数是否相等?相关推荐:《python视频》float 类型不能比较相等或不等,但可以比较>,=,=”或“=-EPSINON) && (x
  • 1 指数表示形式概述4.1 微信公众号:码农阿杰5.1 python 3. 8. 2 documentation1 python 浮点数数据类型概述 浮点数数据类型,可以简称为浮点类型。 小数通常以浮点数的形式存储,在 python 中...
  • Python浮点数误差与解决方法

    千次阅读 2019-07-07 16:11:19
    # 浮点数 print("0.1 + 0.1 = ", 0.1 + 0.1) print("0.1 - 0.1 = ", 0.1 - 0.1) print("0.1 * 0.1 = ", 0.1 * 0.1) #计算机无法精确存储0.01,存储了它的近似值。 print("0.1 / 0.1 = ", 0.1 / 0.1) print("0.3 == 3...
  • python浮点数

    千次阅读 2018-09-30 14:32:09
    Python 中使用更精确的浮点数可以通过 decimal 和 fractions 两个模块,decimal 表示完整的小数,而 fractions 通过分数的形式表示小数 举例: a = Fraction(1,4) print float(a) b = Decimal(0.022) print b 输出:...
  • float类型存放双精度的浮点数,具体取值范围依赖于构建python的c编译器,由于精度受限,进行相等性比较不可靠。如果需要高精度,可使用decimal模块的decimal.Decimal,这种类型可以准确的表示循环小数,但是处理速度...
  • float类型存放双精度的浮点数,具体取值范围依赖于构建python的c编译器,由于精度受限,进行相等性比较不可靠。如果需要高精度,可使用decimal模块的decimal.Decimal,这种类型可以准确的表示循环小数,但是处理速度...
  • 浮点数是用机器上浮点数的本机双精度(64 bit)表示的。提供大约17位的精度和范围从-308到308的指数。和C语言里面的double类型相同。Python不支持32bit的单精度浮点数。如果程序需要精确控制区间和数字精度,可以考虑...
  • python 浮点数判断

    2020-04-17 10:30:55
    最近犯了一个错误,在用pandas处理数据的时候发现float64...原因很简单,本来应该相等的两个浮点数由于计算机内部表示的原因可能略有微小的误差,这时用==就会认为它们不等。 还是python本身基础不牢靠的问题。 ...
  • Python 浮点数转半精度IEEE 754表示 modbus数据传输编码 写modbus编码时遇到,记录一下。 思路是先用numpy将待转换浮点数变为半精度存储,之后用tobytes()将内存里存储的二进制码转化为bytes类型返回,使用unpack...
  • python浮点数陷阱

    2019-05-24 21:15:28
    1、浮点数的二进制表示整数部分:用十进制整数整除以2,得到商和余数,该余数就是二进制数的最低位,然后继续用商整除以2,得到新的商和余数,以此类推,直到商等于0,由所有余数倒排组成了该整数的二进制表现形式。...
  • python 浮点数精确运算解决方案

    万次阅读 多人点赞 2016-04-18 14:50:32
    浮点数误差浮点数一个普遍的问题就是在计算机的世界中,浮点数并不能准确地表示十进制。并且,即便是最简单的数学运算,也会带来不可控制的后果。因为,在计算机的世界中只认识0与1。>>> x = 4.20 >>> y = 2.10 >>> ...
  • python 浮点数未解之谜

    千次阅读 2018-06-05 15:57:04
    疑问: print(8.1+0.03) ouput: 8.129999999999999 print(0.1+0.1+0.1-0.3) output: 5.551115123125783e-17 ...浮点数的二进制表示学习笔记 浮点数算法:争议和限制 浮点数的二进制表示 二、...
  • python浮点数计算是不精确的的,想要精确计算浮点数,需要调用decimal这个模块 decimal是十进制类型 decimal.Decimal(x) #x可以是一个整数或字符串,但不能是浮点数 import decimal a = decimal.Decimal...
  • 您的“关注”和“点赞”,是信任,是认可,是支持,是...小数通常以浮点数的形式存储,在 Python 中用 float 表示。可以理解为浮点数是用来描述小数的。浮点数通常使用 C 中的 double 来实现。Python 中只有一种小数...
  • 现实生活中,我们经常说的一个半小时,其应该用 1.5 个小时来表示。所有浮点数自然存在于生活中,并且广泛存在生活中。所有的浮点数都是近似的。>>> 1.2 * 67.199999999999999>>> 1.2 * 6 == 7.2 # 它们居然不相等...
  • I think the maximum integer in python is available by calling sys.maxint.What is the maximum float or long in Python?解决方案For float have a look at sys.float_info:>>> import sys>>>...
  • 这里有三种方法,round(a,2)'%.2f' % aDecimal('5.000').quantize(Decimal('0.00'))当需要输出的结果要求有两位小数的时候,字符串形式的:'%.2f' % a 方式最好,其次用Decimal。需要注意的:1. 可以传递给Decimal...
  • 浮点数表示方法

    千次阅读 2016-10-11 16:00:47
    IEEE 754 浮点数的格式  ...参考上图,浮点数和双精度数表示方法, s 符号位 (正值为0,负值为1); exponent 阶码 (指数) 偏移量: 浮点数 27-1,双精度浮点数为210-1  + 指数 mantissa 尾数(有
  • Python 浮点数运算

    2016-05-12 04:31:00
    2019独角兽企业重金招聘Python工程师标准>>> ...
  • 基础浮点数是用机器上浮点数的本机双精度(64 bit)表示的。提供大约17位的精度和范围从-308到308的指数。和C语言里面的double类型相同。Python不支持32bit的单精度浮点数。如果程序需要精确控制区间和数字精度,可以...
  • python格式化输出保留2位小数的实现方法我是小白就不用多说了,学习python做了个练习题,结果运行了一遍,发现输入金额后得到的有很多位小数,虽然不知道为什么,但是看得很不舒服,就想到应该把让小数点后只保留2...
  • python实验时碰到这么一道题:输入三个浮点数,求它们的平均值并保留 1 位小数,对小数后第二位数进行四舍五入,最后输出结果错误示范因为涉及到四舍五入,随便搜了一下,发现了好多博客都用round(),就直接拿来用了...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 65,854
精华内容 26,341
关键字:

python浮点数的表示方法

python 订阅