精华内容
下载资源
问答
  • >>> (1.0).is_integer()True>>> (1.555).is_integer()False该方法已添加到floatPython 2.6中的类型。考虑到在Python 2中,1/3是0(整数操作数的分区!),浮点运算可能不精确(a float是使用二进制分数的近似值,而...

    >>> (1.0).is_integer()True>>> (1.555).is_integer()False

    该方法已添加到floatPython 2.6中的类型。

    考虑到在Python 2中,1/3是0(整数操作数的分区!),浮点运算可能不精确(a float是使用二进制分数的近似值,而不是精确的实数)。但是稍微调整一下你的循环会给出:>>> for n in range(12000, -1, -1):... if (n ** (1.0/3)).is_integer():... print n... 27810

    这意味着由于上述不精确的原因,超过3立方(包括10648)的任何东西都被遗漏了:>>> (4**3) ** (1.0/3)3.9999999999999996>>> 10648 ** (1.0/3)21.999999999999996

    您必须检查接近整个号码的号码,或者不用float()来查找您的号码。就像舍入以下的立方根12000:>>> int(12000 ** (1.0/3))22>>> 22 ** 310648

    如果您使用的是Python 3.5或更高版本,则可以使用该math.isclose()函数查看浮点值是否在可配置的边距内:>>> from math import isclose>>> isclose((4**3) ** (1.0/3), 4)True>>> isclose(10648 ** (1.0/3), 22)True

    对于旧版本,PEP485中提到的该函数的初始实现(跳过错误检查并忽略无穷大和NaN):def isclose(a, b, rel_tol=1e-9, abs_tol=0.0):

    return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)

    展开全文
  • I have a list of floating-point values in Python:floats = [3.14, 2.7, 0.0, -1.0, 1.1]I would like to write these values out to a binary file using IEEE 32-bit encoding. What is the best way to do this...

    I have a list of floating-point values in Python:

    floats = [3.14, 2.7, 0.0, -1.0, 1.1]

    I would like to write these values out to a binary file using IEEE 32-bit encoding. What is the best way to do this in Python? My list actually contains about 200 MB of data, so something "not too slow" would be best.

    Since there are 5 values, I just want a 20-byte file as output.

    解决方案

    Alex is absolutely right, it's more efficient to do it this way:

    from array import array

    output_file = open('file', 'wb')

    float_array = array('d', [3.14, 2.7, 0.0, -1.0, 1.1])

    float_array.tofile(output_file)

    output_file.close()

    And then read the array like that:

    input_file = open('file', 'r')

    float_array = array('d')

    float_array.fromstring(input_file.read())

    array.array objects also have a .fromfile method which can be used for reading the file, if you know the count of items in advance (e.g. from the file size, or some other mechanism)

    展开全文
  • 本篇讨论的现象可以从下面这段脚本体现出来:>>>x=0.0>>>foriinrange(10):x+=0.1print(x)0.10.20.300000000000000040.40.50.60.70.79999999999999990....因为 Python 中使用双精度浮点数来存储小数。在 ...

    本篇讨论的现象可以从下面这段脚本体现出来:

    >>>

    x

    =

    0.0

    >>>

    for

    i

    in

    range(

    10

    ):

    x

    +=

    0.1

    print

    (x)

    0.1

    0.2

    0.30000000000000004

    0.4

    0.5

    0.6

    0.7

    0.7999999999999999

    0.8999999999999999

    0.9999999999999999

    >>>

    即:为什么有几行的输出看起来不对?

    因为 Python 中使用双精度浮点数来存储小数。在 Python 使用的 IEEE 754 标准(52M/11E/1S)中,8字节64位存储空间分配了52位来存储浮点数的有效数字,11位存储指数,1位存储正负号,即这是一种二进制版的科学计数法格式。虽然52位有效数字看起来很多,但麻烦之处在于,二进制小数在表示有理数时极易遇到无限循环的问题。其中很多在十进制小数中是有限的,比如十进制的 1/10,在十进制中可以简单写为 0.1 ,但在二进制中,他得写成:0.0001100110011001100110011001100110011001100110011001…..(后面全是 1001 循环)。因为浮点数只有52位有效数字,从第53位开始,就舍入了。这样就造成了标题里提到的”浮点数精度损失“问题。 舍入(round)的规则为“0 舍 1 入”,所以有时候会稍大一点有时候会稍小一点。

    Python 的浮点数类型有一个 .hex()方法,调用能够返回该浮点数的二进制浮点数格式的十六进制版本。这话听着有点绕,其实是这样的:本来浮点数应该有一个 .bin() 方法,用来返回其二进制浮点数格式。如果该方法存在的话,它看起来就像这样(p-4表示乘以 2-4,或者可以简单理解为小数点 左移 4 位):

    >>>

    (

    0.1

    ).bin()

    #

    本方法其实并不存在

    '

    1.1001100110011001100110011001100110011001100110011010p-4

    '

    但是这个字符串太长了,同时因为每 4 位二进制字符都可以换算成 1 位十六进制字符,于是Python就放弃了给浮点数提供 .bin() 方法,改为提供 .hex() 方法。这个方法将上面输出字符串的 52 位有效数字无损转换成了 13 位十六进制数字,所以实际存在的方法其实是这样的(注:二进制浮点数中小数点前的“1”不包含于那 52 位有效数字之中):

    >>>

    (

    0.1

    ).hex()

    '

    0x1.999999999999ap-4

    '

    前面的 0x 代表十六进制。p-4 没变,所以需要注意,这里的 p-4 还是二进制版的,也就是说在展开本格式的时候,你不能把小数点往左移 4 位,那样就相当于二进制左移 16 位了。前面提到过,小数点前这个“1”是不包含于 52 位有效数字之中的,但它确实是一个有效的数字呀,这是因为,在二进制浮点数中,第一位肯定是“1”,(是“0”的话就去掉这位,并在指数上-1)所以就不保存了,这里返回的这个“1”,是为了让人看懂而加上的,在内存的 8 位空间中并没有它。所以 .hex() 方法在做进制转换的时候,就没有顾虑到这个“1”,直接把 52 位二进制有效数字转换掉就按着原来的格式返回了。因此这个 .hex() 方法即使名义上返回的是一个十六进制数,它小数点前的那一位也只会是“1”,看下面示例:

    >>>

    float.fromhex(

    '

    0x1.8p+1

    '

    )

    ==

    float.fromhex(

    '

    0x3.0p+0

    '

    )

    True

    一般我们用十六进制科学计数法来表示 3.0 这个数时,都会这么写“0x3.0p+0”。但是 Python 会这么写“0x1.8p+1”,即“1.1000”小数点右移一位变成“11.000”——确实还是 3.0 。就是因为这个 1 是直接遗传自二进制格式的。而我一开始没有理解这个 .hex() 的意义,还画蛇添足地自定义了一个 hex2bin() 方法,后来看看真是没必要啊~

    而为了回应人们在某些状况下对这个精度问题难以忍受的心情(雾),Python 提供了另一种数字类型——Decimal 。他并不是内建的,因此使用它的时候需要 import decimal 模块,并使用 decimal.Decimal() 来存储精确的数字。这里需要注意的是:使用非整数参数时要记得传入一个字符串而不是浮点数,否则在作为参数的时候,这个值可能就已经是不准确的了:

    >>>

    Decimal(

    0.1

    )

    ==

    Decimal(

    '

    0.1

    '

    )

    False

    在进一步研究到底损失了多少精度,或者说,八字节双精度浮点数最多可以达到多少精度的问题之前,先来整理一下小数和精度的概念。本篇中讨论的小数问题仅限于有理数范围,其实有理数也是日常编程中最常用到的数。有理数(rational number)一词派生于“比(ratio)”,因此并不是“有道理”的意思,而是指分数。有理数的内容扩展自自然数,由自然数通过有理运算(+ – * /)来得到的数系称为有理数,因此可以看到它较自然数扩充了:零、负整数和分数的部分。有理数总可以写成 p/q 的形式,其中 p、q 是整数且 q ≠ 0,而且当 p 和 q 没有大于 1 的公因子且 q 是正数的时候,这种表示法就是唯一的。这也就是有理数被称为 rational number 的原因,说白了就是分数。实际上 Python 的 float 类型还有一个 .as_integer_ratio() 的方法,就可以返回这个浮点数的最简分数表示,以一个元组的形式:

    >>>

    (

    0.5

    ).as_integer_ratio()

    (

    1

    ,

    2

    )

    然后为了对有理数套用更直观的“位值法”表示形式,人们又开始用无限小数的形式表示有理数。而其中从某一位开始后面全是 0 的特殊情况,被称为有限小数(没错,无限小数才是本体)。但因为很多时候我们只需要有限位有效数字的精度就够用了,所以我们会将有理数保存到某一位小数便截止。后面多余小数的舍入方式便是“四舍五入”,这种方式较直接截断(round_floor)的误差更小。在二进制中,它表现为“0 舍 1 入”。当我们舍入到某一位以后,我们就可以说该数精确到了那一位。如果仔细体会每一位数字的含义就会发现,在以求得有限小数位下尽可能精确的值为目的情况下,直接截断的舍入方式其实毫无意义,得到的那最后一位小数也并不准确。例如,将 0.06 舍入成 0.1 是精确到小数点后一位,而把它舍入成 0.0 就不算。因此,不论是在双精度浮点数保留 52 位有效数字的时候,还是从双精度浮点数转换回十进制小数并保留若干位有效数字的时候,对于最后一位有效数字,都是需要舍入的。

    插一句题外话:如何判断一个有理数在写成某种进制的小数时是否具有有限长度。就是看这个有理数的分母的质因子,是否全部包含于进制的质因子之中。举个栗子,1/2 这个数在二进制、四进制和八进制...中都是有限小数,但在三进制、五进制和七进制...中都是无限小数。同样道理,十进制下 1/n (n为整数,0

    下图是一个(0,1)之间的数轴,上面用二进制分割,下面用十进制分割。比如二进制的 0.1011 这个数,从小数点后一位一位的来看每个数字的意义:开头的 1 代表真值位于 0.1 的右侧,接下来的 0 代表真值位于 0.11 的左侧,再接下来的 1 代表真值位于 0.101 的右侧,最后的 1 代表真值位于 0.1011 的右侧(包含正好落在 0.1011 上这种情况,这就是四舍五入的来源)。使用 4 位二进制小数表示的 16 个不同的值,除去 0,剩下的 15 个数字正好可以平均分布在(0,1)这个区间上,而十进制只能平均分布 9 个数字。显然 4 位二进制小数较于 1 位十进制小数将此区间划分的更细,即精度更高。

    21232703_pHMj.jpg

    把 0.1 的双精度版本(0x1.999999999999ap-4)展开成十进制。这里使用了 Decimal 类型,在给他赋值的时候,他会完整存储参数,但是要注意的是,使用 Decimal 进行运算是会舍入的,保留的位数由上下文决定。使用 decimal 模块的 getcontext() 方法可以得到上下文对象,其中的 prec 属性就是精度。下面还使用了 print() 方法,这是为了好看:

    >>>

    print

    (Decimal(

    0.1

    ))

    0.1000000000000000055511151231257827021181583404541015625

    得到的这个十进制浮点数有效数字足有 55 位。虽然从二进制到十进制这个过程是完全精确的,但因为在存储这个二进制浮点数的时候进行了舍入,所以这个 55 位的十进制数,较于最初的 0.1 并不准确。至于到底能精确到原十进制数的哪一位,可以这么算: 2**53 = 9007199254740992 ≈ 10**16 ,(这里 53 算上了开头的“1”),即转换后的十进制小数的第 16 位有效数字很可能是精确的(第 15 位肯定是精确的)。换句话说,如果要唯一表示一个 53 位二进制数,我们需要一个 17 位的十进制数(但即使这样,也不代表对应的十进制和二进制数“相等”,他们只不过在互相转换的时候在特定精度下可以得到相同的的值罢了。就像上面例子中显示的,精确表示”0.1“的双精度版本,需要一个 55 位的十进制小数)。

    不过可以看到,如果要保证转换回来的十进制小数与原值相等,那么只能保证到 15 位,第 16 位只是“很可能是精确的”。而且第 15 位的精确度也要依赖于第 16 位的舍入。实际上在 C++ 中,double 类型的十进制小数就是保留 15 位的(我从别处看来的,C++我自己并不熟悉)。所以如果 Python 的 float 类型的 __str__() 和 __repr__() 方法选择返回一个 15 位的小数,那么就不会出现本文讨论的第一个问题了。不论是早期的“0.10000000000000001”还是本文中出现的“0.30000000000000004”或者“0.7999999999999999”,我们可以看到它的不精确都是因为打印了过多位的有效数字——16 或 17 。假如强制 round 到 15 位的话:

    a

    =

    0.1

    for

    i

    in

    range(

    10

    ):

    print

    (round(a,

    15

    ))

    a

    +=

    0.1

    0.1

    0.2

    0.3

    0.4

    0.5

    0.6

    0.7

    0.8

    0.9

    1.0

    我们再来看一下他的 16、17 位到底保存了什么:

    >>>

    a

    =

    0.0

    >>>

    for

    i

    in

    range(

    10

    ):

    a

    +=

    0.1

    print

    (a)

    print

    (

    '

    %.17f

    '

    %

    a)

    print

    (

    '

    -

    '

    *

    19

    )

    0.1

    0.10000000000000001

    -------------------

    0.2

    0.20000000000000001

    -------------------

    0.30000000000000004

    0.30000000000000004

    -------------------

    0.4

    0.40000000000000002

    -------------------

    0.5

    0.50000000000000000

    -------------------

    0.6

    0.59999999999999998

    -------------------

    0.7

    0.69999999999999996

    -------------------

    0.7999999999999999

    0.79999999999999993

    -------------------

    0.8999999999999999

    0.89999999999999991

    -------------------

    0.9999999999999999

    0.99999999999999989

    -------------------

    上面短横线对齐的是第 17 位。虽然在这里第 16 位全部是精确的,但如果为了保证 100% 的准确率的话,还是需要舍入到第 15 位。另外一个细节,上面的例子其实有一个问题,就是使用 0.1++ 这种方式的时候,实际累加的是一个不精确的数字,所以有可能造成误差的放大。不过这里依然没有改正,是因为 0.5 那行,突然恢复真值了。这也不是因为后面藏了其他数字没有显示出来,我们来看一下:

    >>>

    '

    %.60f

    '

    %

    (

    0.1

    +

    0.1

    +

    0.1

    +

    0.1

    +

    0.1

    )

    '

    0.500000000000000000000000000000000000000000000000000000000000

    '

    >>>

    print

    (Decimal(

    0.1

    +

    0.1

    +

    0.1

    +

    0.1

    +

    0.1

    ))

    0.5

    这里使用了一个格式限定符的示例。它的作用类似于 print Decimal。区别仅在于 Decimal 自己知道应该显示多少位,而格式化限定符不知道。(一般双精度浮点数转换过来不超过 100 位)。因为不打算继续深究了,所以就当这个“0.5”是个意外吧~如果想避免误差叠加,可以写成“i/10”的格式。

    所以对于两种,不像十六进制和二进制般正好是指数关系的进制,永远都无法在各自的某一位上具有相同的精度。即 2m = 10n 这个等式没有使 m,n 同时为整数的解。但至少还可以构建一个精度包含的关系,比如上面 24 > 101 ,那么我们就说“4 位二进制精度高于 1 位十进制精度”从而通过 4 位二进制数转储 1 位十进制数的时候,总是精确的,反之则不然。同理根据这个不等式:1015 < 253 <1016 ,双精度浮点数的精度最高也就蕴含(不是等价)到十进制的 15 位了。另外虽然这种转化看起来浪费了很大的精度(第 16 位在很大概率上也是精确的)。有趣的是,210 = 1024,却和 103 = 1000 离的很近。因此一般我们可以通过这个 10:3 的比例来近似推导精度关系。

    最后,因为浮点数的这点特性,在涉及到钱的地方都是不用浮点数的,他们会用定点数。即使用 ...xxxxx . xx 的格式存储数字,精确到小数点后第二位,即“分”。

    展开全文
  • Python 提取浮点数

    万次阅读 2017-02-16 10:28:03
    python 提取文本中的浮点数,包括整数,小数,科学计数法,公式为 temp = re.findall(r'-?\d+\.?\d*e?-?\d*?', line) 该公式只能够处理完全正确的浮点数,除了浮点数也有可能存在其他字符串满足该公式, 该...

    python 提取文本中的浮点数,包括整数,小数,科学计数法,公式为

    temp = re.findall(r'-?\d+\.?\d*e?-?\d*?', line)
    该公式只能够处理完全正确的浮点数,除了浮点数也有可能存在其他字符串满足该公式,

    该公式纯粹是为了从文本中提取数字,数字必须是正确的,该公式不具有判断是否为浮点数的功能,只是能够提取浮点数,即使浮点数是错误的格式

    展开全文
  • 浮点数简单来说就是实数,也叫小数,不同于整数,其带有小数部分。浮点数广泛用于统计和科学计算上。现实生活中,我们经常说的一个半小时,其应该用 1.5 个小时来表示。所有浮点数自然存在于生活中,并且广泛存在...
  • 3-8 Python浮点数和布尔型

    千次阅读 2017-03-08 22:06:37
    Python浮点数和布尔型 Python浮点数和布尔型 3-8 Python中整数和浮点数 3-9 Python中布尔类型3-8 Python中整数和浮点数Python支持对整数和浮点数直接进行四则混合运算,运算规则和数学上的四则运算规则完全一致...
  • python-浮点数取整

    千次阅读 2020-11-06 20:27:18
    1.向下取整--int() 直接截去小数点后部分 >>> int(454) 454 >...2.四舍五入--round() 返回浮点数四舍五入的值。ps:python2和python3中不同。 python2中,标准的四舍五入,对四舍五入.
  • 在深入了解浮点数的实现之前,先来看几个 Python 浮点数计算有意思的例子:0.1 == 0.10000000000000000000001IEEE 浮点数表示法这些看起来违反常识的“错误”并非 Python 的错,而是由浮点数的规则所决定的,即使放...
  • python 浮点数判断

    2020-04-17 10:30:55
    最近犯了一个错误,在用pandas处理数据的时候发现float64数据貌似不能直接使用==判断相等。 想着是不是浮点数精度的问题导致的,于是改成了abs(x - y) < 1e-7的形式果然就可以了 原因很简单,本来应该相等...
  • str为字符串s为字符串str.isalnum() 所有字符都是数字或者字母str.isalpha() 所有字符都是字母str.isdigit() 所有字符都是数字str.isspace() 所有字符都是空白字符、\t、\n、\r检查字符串是数字/浮点数方法float部分...
  • Python的核心数据类型:数字(整数,浮点数,复数,布尔型)整形数 int整数是不带有小数部分的数字,包括自然数,零,负自然数如: -5 100 0 88888整形数的字面值表示方式十进制表示方式如:102009999999999999999二...
  • 浮点数二进制与十进制之间的转换 在使用遗传算法的时候,需要对数据进制二进制编码,所以改的这个浮点数不同进制之间转换的一个代码 直接上代码 #二进制转化为十进制浮点数 def todecimal(n): ''' 把一个带小数的...
  • python如何比较两个浮点数是否相等?相关推荐:《python视频》float 类型不能比较相等或不等,但可以比较>,=,=”或“=-EPSINON) && (x
  • 浮点数简单来说就是实数,也叫小数,不同于整数,其带有小数部分。浮点数广泛用于统计和科学计算上。现实生活中,我们经常说的一个半小时,其应该用 1.5 个小时来表示。所有浮点数自然存在于生活中,并且广泛存在...
  • 浮点数的表示 import struct while 1: try:a=float(input("输入一个数,他会输出对应的浮点数结构,输入非数类退出:")) except:break else: print(''.join(bin(h).replace('0b','').rjust(8,'0') for h in ...
  • 原博文2013-09-16 12:30 −第一次写python,真是蛇年学python的节奏。 在本程序中想进行如下一个循环,并在最后一层中进行一个if判断:当ini_allocation中得元素之和为1时进行下面的part。 1 for i in range(0,11): ...
  • 一、整数类型(int)整数就是没有小数部分的数字,Python中的整数包括正整数、0 和负整数。有些强类型的编程语言会提供多种整数类型,每种类型的长度都不同,能容纳的整数的大小也不同,开发者要根据实际数字的大小...
  • s为字符串 s.isalnum() 所有字符都是数字或者字母 ...浮点数判断 type(eval( " 123 " )) == int type(eval( " 123.23 " )) == float   转载于:https://www.cnblogs.com/hitnoah/p/3918109.html
  • 目录python 浮点数数据类型概述2. 2. 1 指数表示形式概述4.1 微信公众号:码农阿杰5.1 python 3. 8. 2 documentation1 python 浮点数数据类型概述 浮点数数据类型,可以简称为浮点类型。 小数通常以浮点数的形式存储...
  • 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 输出:...
  • 2019独角兽企业重金招聘Python工程师标准>>> ...
  • python如何判断整数和浮点数

    万次阅读 2018-12-20 14:30:53
    首先是解决我问题的方法,使用isinstance(i,float/int)判断: i=9,j=1.3 &gt;&gt;isinstance(i,int) &gt;&gt;True &gt;&gt;isinstance(i,float) &gt;&gt;False &gt;&gt;...
  • str为字符串s为字符串str.isalnum() 所有字符都是数字或者字母str.isalpha() 所有字符都是字母str.isdigit() 所有字符都是数字str.isspace() 所有字符都是空白字符、\t、\n、\r检查字符串是数字/浮点数方法float部分...
  • 判断浮点数是否为整数浮点数还是小数浮点数 我们一般可以通过type(x)函数直接获取x的数据类型,或者通过isinstance(x, datatype)来判断x是否为datatype类型。但是,有时候,我们需要将如20.0这样小数位无值、类似于...
  • str为字符串s为字符串str.isalnum() 所有字符都是数字或者字母str.isalpha() 所有字符都是字母str.isdigit() 所有字符都是数字str.isspace() 所有字符都是空白字符、t、n、r检查字符串是数字/浮点数方法float部分>> ...
  • 主要给大家介绍了Python中关于浮点数的冷知识,文中通过示例代码介绍的非常详细,对大家学习或者使用Python具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • Python中处理字符串的函数比较丰富,有时需要把字符串转化为整形、浮点型等;转换过程中,发现有时会报错,比如字符串“12*76”,转换为整形,直接转换int(“12*76”),会报无法转换的错误的,因为*无法转换为整形...
  • Python 里面,这个加法的结果如下图所示:因为这个原因,我们显然不能直接用等号判断两个浮点数是否相等,如下图所示:在工程上,我们不要求绝对精确,只要求足够精确就可以了。所以,当我们要判断两个数是否相等...
  • Python浮点数range

    千次阅读 2018-10-13 12:48:41
    问题提出:最近在用matplotlib定义坐标轴,需要会出现型... 最初觉得这个问题很简单, 虽然python的range是不支持浮点数的,np可以实现出现下面的代码``` import numpy as np print(list(map(lambda a:str(a),n...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,324
精华内容 13,329
关键字:

python判断浮点数

python 订阅