如何使用十进制range()步长值?


742

有没有办法在0和1之间以0.1步进?

我以为我可以像下面那样做,但是失败了:

for i in range(0, 1, 0.1):
    print i

相反,它说step参数不能为零,这是我没有想到的。


17
int(0.1)== 0,所以步长实际上为零。这可能是意外的,但它为零。您可能想重新陈述您的问题,以反映您没想到的事实。说“不是”是错误和误导的。
S.Lott

3
顺便说一句,可以使用itertools.takewhile和折叠一个短衬纸itertools.count。不过,这并不比drange性能更好。
科斯2012年

1
令人尴尬的是python的范围不允许这样做,因为实现生成器即使不累积舍入错误也很容易做到这一点。哎呀,即使是seqGNU coreutils中的工具也可以做到seq 0 0.1 1无舍入错误!
josch,2016年

3
@josch:内部seq使用C long double类型,并且出现舍入错误。例如,在我的机器上,seq 0 0.1 1给出1作为其最后的输出(如预期),但seq 1 0.1 2给出1.9作为最后的输出(而不是期望2)。
Mark Dickinson

为了方便起见,@ Kos的建议可以按itertools.takewhile(lambda x: (x+0.05)<1, itertools.count(0,0.1))itertools.islice(itertools.count(0,0.1), 10)(在您拥有之后import itertools)实施,尽管我尚未测试哪种效率更高
匿名

Answers:


905

与直接使用小数步相比,用所需的点数表示这一点要安全得多。否则,浮点舍入错误可能会给您带来错误的结果。

您可以使用NumPy库中的linspace函数(该库不是标准库的一部分,但相对容易获得)。需要返回多个点,还可以指定是否包括正确的端点:linspace

>>> np.linspace(0,1,11)
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9,  1. ])
>>> np.linspace(0,1,10,endpoint=False)
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])

如果您确实要使用浮点阶跃值,可以使用numpy.arange

>>> import numpy as np
>>> np.arange(0.0, 1.0, 0.1)
array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])

但是,浮点舍入错误引起问题。这是一个简单的情况,当四舍五入错误arange仅应产生3个数字时,会导致产生长度为4的数组:

>>> numpy.arange(1, 1.3, 0.1)
array([1. , 1.1, 1.2, 1.3])

51
numpy是python的一个无处不在的组件,我认为这个答案是最“ pythonic”的。
空袭2013年

21
@AndreTerra问题在于@ numpy @是第三方程序包,在依赖关系管理,存储(对于程序包本身)等方面增加了很多开销。根据开发人员的操作,可能无法使用它。
rbaleksandar '17

请原谅,但自那以后我不理解浮点舍入错误,np.linspace(1.,1.3,4)np.arange(1.,1.3,0.1)给出了完全相同的输出
死代码

4
@deadcode原因是np.arange被定义为产生一个范围[start,stop)(即不包括stop),因此不希望列表中包含1.3。请参阅此问题,以了解为什么仍要包含它以及如何处理它。
丹尼斯

5
可以说使用了多少包并不能完全表明它是否是“ Pythonic”。
Alex Hall,

213

Python的range()只能做整数,不能做浮点数。在您的特定情况下,可以改用列表推导:

[x * 0.1 for x in range(0, 10)]

(用该表达式将调用替换为range。)

对于更一般的情况,您可能需要编写自定义函数或生成器。


36
更好的是,如果您使用的是Python 2.4+,则可以只使用生成器理解。(x * 0.1 for x in range(0, 10))
JAB

42
甚至更好,把x/10代替 x * 0.1:d没什么特别实际的,但在那里的一些数字会更精确,例如,对于3*0.10.30000000000000004,而3/10你0.3:)
小子

4
3/10给我0,而不是0.3。3 / 10.0给出0.29999999999999999。Python 2.6。

19
@LarsWirzenius:在Python 2.2+中,from __future__ import division; 3/10返回0.3。此行为是Python 3.x中的默认行为。
本杰明·霍奇森

2
还可以使用取整函数lst = [对于范围(0,10)中的x,取整(x(0.1 * 0.2))
MARK

148

'xrange([start],stop [,step])'的基础上,您可以定义一个生成器,该生成器接受并产生您选择的任何类型(坚持支持+and的类型<):

>>> def drange(start, stop, step):
...     r = start
...     while r < stop:
...         yield r
...         r += step
...         
>>> i0=drange(0.0, 1.0, 0.1)
>>> ["%g" % x for x in i0]
['0', '0.1', '0.2', '0.3', '0.4', '0.5', '0.6', '0.7', '0.8', '0.9', '1']
>>> 

45
这具有舍入问题。请在此处查看:code.activestate.com/recipes/66472
Christian Oudard

我会用((r>停止),同时给出相反方向的r-=步骤)将其扩展到另一个方向。
user318904

1
我做了一个xfrange函数,没有上面提到的浮点精度问题。检查出来;)stackoverflow.com/questions/477486/…–
卡洛斯·维加

1
您正在累积舍入错误。请改用:`i = 0; r =开始,而r <停止:i + = 1; r =开始+ i *步骤;收益r`
Cees Timmerman

1
这来自pythoncentral.io/pythons-range-function-explained(和其他Python文档资源)
Apostolos

31

增大i循环的幅度,然后在需要时减小它。

for i * 100 in range(0, 100, 10):
    print i / 100.0

编辑:老实说,我不记得为什么我认为这将在语法上起作用

for i in range(0, 11, 1):
    print i / 10.0

那应该具有所需的输出。


我认为您会发现range()可处理整数,在这种情况下,这将是使用相同的函数(至少)的唯一解决方案。
马修·沙利

1
@cmsjr creative:D仅需注意一点:如果使用的是Python 2.x,请除以100.0以防止Python截断结果。我认为在3.0中,它将按照您的编码进行工作。
Dana

2
for i * 100 in range(0, 100, 10):SyntaxError:无法分配给运算符
Anne van Rossum 2015年

25

scipy有一个内置函数arange,可以泛化Python的range()构造函数,以满足您对float处理的要求。

from scipy import arange


8
这实际上与arange您在numpy中可以找到的完全相同:>>> import scipy >>> import numpy >>> numpy.arange is scipy.arange将返回True
iFreilicht

from nump import arange as range
shrewmouse

24

我认为NumPy有点矫kill过正。

[p/10 for p in range(0, 10)]
[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]

一般来说,逐步1/x进行y将可以

x=100
y=2
[p/x for p in range(0, int(x*y))]
[0.0, 0.01, 0.02, 0.03, ..., 1.97, 1.98, 1.99]

1/x我测试时产生的舍入噪音较小)。


18

类似于R的 seq函数,该函数以正确的步长值以任意顺序返回序列。最后一个值等于停止值。

def seq(start, stop, step=1):
    n = int(round((stop - start)/float(step)))
    if n > 1:
        return([start + step*i for i in range(n+1)])
    elif n == 1:
        return([start])
    else:
        return([])

结果

seq(1, 5, 0.5)

[1.0、1.5、2.0、2.5、3.0、3.5、4.0、4.5、5.0]

seq(10, 0, -1)

[10、9、8、7、6、5、4、3、2、1、0]

seq(10, 0, -2)

[10、8、6、4、2、0]

seq(1, 1)

[1]


2
对于想要在不过多了解python的情况下获得它的人来说,这是一个很好的答案。
Chani 2014年

1
几乎是我一直在寻找的东西-注意seq(0.5, 3.0)返回[0.5, 1.5, 2.5, 3.5]。为了避免最后的条目被外的范围内,代替n = int(round(...n = int(floor(...用线from math import floor在顶部(上方def seq(...)。
FriendFX 2015年

2
@FriendFX不要这样做!如果floor使用,seq(0.2, 0.9, 0.1)将无法到达正确的终点并返回[0.2, 0.30000000000000004, 0.4, 0.5, 0.6000000000000001, 0.7, 0.8]
fdermishin

@ user502144:很好,谢谢。我想我必须选择一种更复杂的解决方案,以保持其通用性。
FriendFX

14

恐怕range()内置函数会返回一个整数值序列,因此您不能使用它执行小数步。

我想说的只是使用while循环:

i = 0.0
while i <= 1.0:
    print i
    i += 0.1

如果您好奇,Python会将您的0.1转换为0,这就是为什么它告诉您参数不能为零的原因。


2
不要这样!加.110次​​与加1docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html

12

这是使用itertools的解决方案:

import itertools

def seq(start, end, step):
    if step == 0:
        raise ValueError("step must not be 0")
    sample_count = int(abs(end - start) / step)
    return itertools.islice(itertools.count(start, step), sample_count)

用法示例:

for i in seq(0, 1, 0.1):
    print(i)

为了完整起见,您应该计算sample_count变量的绝对值,这样您的函数也将以负数开头(即从-10到10)工作
Deleteman

10
[x * 0.1 for x in range(0, 10)] 

在Python 2.7x中,结果如下:

[0.0、0.1、0.2、0.30000000000000004、0.4、0.5、0.6000000000000001、0.7000000000000001、0.8、0.9]

但如果您使用:

[ round(x * 0.1, 1) for x in range(0, 10)]

给您所需的:

[0.0、0.1、0.2、0.3、0.4、0.5、0.6、0.7、0.8、0.9]



5

而且,如果您经常这样做,则可能要保存生成的列表 r

r=map(lambda x: x/10.0,range(0,10))
for i in r:
    print i


4

我的版本使用原始的范围函数来为班次创建乘法索引。这允许与原始范围函数使用相同的语法。我做了两个版本,一个使用浮点,一个使用十进制,因为我发现在某些情况下我想避免浮点算术引入的舍入漂移。

它与范围/ xrange中的空集结果一致。

仅将单个数值传递给任何一个函数都将使标准范围输出返回到输入参数的整数上限值(因此,如果给定5.5,它将返回range(6)。)

编辑:下面的代码现在可以在pypi上作为软件包使用:Franges

## frange.py
from math import ceil
# find best range function available to version (2.7.x / 3.x.x)
try:
    _xrange = xrange
except NameError:
    _xrange = range

def frange(start, stop = None, step = 1):
    """frange generates a set of floating point values over the 
    range [start, stop) with step size step

    frange([start,] stop [, step ])"""

    if stop is None:
        for x in _xrange(int(ceil(start))):
            yield x
    else:
        # create a generator expression for the index values
        indices = (i for i in _xrange(0, int((stop-start)/step)))  
        # yield results
        for i in indices:
            yield start + step*i

## drange.py
import decimal
from math import ceil
# find best range function available to version (2.7.x / 3.x.x)
try:
    _xrange = xrange
except NameError:
    _xrange = range

def drange(start, stop = None, step = 1, precision = None):
    """drange generates a set of Decimal values over the
    range [start, stop) with step size step

    drange([start,] stop, [step [,precision]])"""

    if stop is None:
        for x in _xrange(int(ceil(start))):
            yield x
    else:
        # find precision
        if precision is not None:
            decimal.getcontext().prec = precision
        # convert values to decimals
        start = decimal.Decimal(start)
        stop = decimal.Decimal(stop)
        step = decimal.Decimal(step)
        # create a generator expression for the index values
        indices = (
            i for i in _xrange(
                0, 
                ((stop-start)/step).to_integral_value()
            )
        )  
        # yield results
        for i in indices:
            yield float(start + step*i)

## testranges.py
import frange
import drange
list(frange.frange(0, 2, 0.5)) # [0.0, 0.5, 1.0, 1.5]
list(drange.drange(0, 2, 0.5, precision = 6)) # [0.0, 0.5, 1.0, 1.5]
list(frange.frange(3)) # [0, 1, 2]
list(frange.frange(3.5)) # [0, 1, 2, 3]
list(frange.frange(0,10, -1)) # []

怎样才能frange当停止工作是None?该部分代码甚至不再考虑步长。
josch

1
@josch range有两个签名:range(stop),假定默认值start=0, step=1,和range(start, stop, step),不作任何假设。frange反映出这一点。当使用range(stop)签名,都frangedrange在0和增量由1开始,所以他们的行为等同于常规的range(stop)与停车行为四舍五入到最接近的整数。
Nisan.H 2016年

4

这是我获得浮动步距范围的解决方案。
使用此功能,无需导入numpy或安装它。
我很确定可以对其进行改进和优化。随意做并张贴在这里。

from __future__ import division
from math import log

def xfrange(start, stop, step):

    old_start = start #backup this value

    digits = int(round(log(10000, 10)))+1 #get number of digits
    magnitude = 10**digits
    stop = int(magnitude * stop) #convert from 
    step = int(magnitude * step) #0.1 to 10 (e.g.)

    if start == 0:
        start = 10**(digits-1)
    else:
        start = 10**(digits)*start

    data = []   #create array

    #calc number of iterations
    end_loop = int((stop-start)//step)
    if old_start == 0:
        end_loop += 1

    acc = start

    for i in xrange(0, end_loop):
        data.append(acc/magnitude)
        acc += step

    return data

print xfrange(1, 2.1, 0.1)
print xfrange(0, 1.1, 0.1)
print xfrange(-1, 0.1, 0.1)

输出为:

[1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0]
[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1]
[-1.0, -0.9, -0.8, -0.7, -0.6, -0.5, -0.4, -0.3, -0.2, -0.1, 0.0]

1
如果最后一个值在停止值的1步之内,则缺少最后一个值会出错。即xfrange(1,10,2)仅做1,3,5,7,缺少9
Lobe

供参考和其他读者使用,请将此实现与此stackoverflow.com/a/477610/54964进行比较。这似乎没有大的浮动问题。
莱奥列奥波尔德·赫兹준 영

@carlosvega您能确认Lobe为什么得到他的结果吗?
莱奥列奥波尔德·赫兹준 영

3

为了完善精品店,提供了一个实用的解决方案:

def frange(a,b,s):
  return [] if s > 0 and a > b or s < 0 and a < b or s==0 else [a]+frange(a+s,b,s)

2

您可以使用此功能:

def frange(start,end,step):
    return map(lambda x: x*step, range(int(start*1./step),int(end*1./step)))

似乎无法正常工作,例如list(frange(99.8, 100.1, 0.1)) => [99.7, 99.80000000000001, 99.9]
Shai Coleman

2

诀窍避免四舍五入问题是使用一个单独的号码通过的范围内移动,启动和一半一步提前开始

# floating point range
def frange(a, b, stp=1.0):
  i = a+stp/2.0
  while i<b:
    yield a
    a += stp
    i += stp

或者,numpy.arange可以使用。


2

可以使用Numpy库完成。arange()函数允许进行浮动操作。但是,它返回一个numpy数组,为方便起见,可以使用tolist()将其转换为list。

for i in np.arange(0, 1, 0.1).tolist():
   print i

2

我的答案与使用map()的其他答案相似,不需要NumPy,也不需要使用lambda(尽管可以)。要以dt的步长获取从0.0到t_max的浮点值列表:

def xdt(n):
    return dt*float(n)
tlist  = map(xdt, range(int(t_max/dt)+1))

2

出人意料的是,尚未在Python 3文档中提及推荐的解决方案:

也可以看看:

  • linspace配方展示了如何实现一个懒惰的版本范围的适用于浮点应用程序。

定义后,该配方易于使用,不需要numpy或任何其他外部库,但功能类似于numpy.linspace()。请注意,step第三个num参数不是参数,而是指定所需值的数量,例如:

print(linspace(0, 10, 5))
# linspace(0, 10, 5)
print(list(linspace(0, 10, 5)))
# [0.0, 2.5, 5.0, 7.5, 10]

我在下面引用了安德鲁·巴纳特(Andrew Barnert)的完整Python 3配方的修改版:

import collections.abc
import numbers

class linspace(collections.abc.Sequence):
    """linspace(start, stop, num) -> linspace object

    Return a virtual sequence of num numbers from start to stop (inclusive).

    If you need a half-open range, use linspace(start, stop, num+1)[:-1].
    """
    def __init__(self, start, stop, num):
        if not isinstance(num, numbers.Integral) or num <= 1:
            raise ValueError('num must be an integer > 1')
        self.start, self.stop, self.num = start, stop, num
        self.step = (stop-start)/(num-1)
    def __len__(self):
        return self.num
    def __getitem__(self, i):
        if isinstance(i, slice):
            return [self[x] for x in range(*i.indices(len(self)))]
        if i < 0:
            i = self.num + i
        if i >= self.num:
            raise IndexError('linspace object index out of range')
        if i == self.num-1:
            return self.stop
        return self.start + i*self.step
    def __repr__(self):
        return '{}({}, {}, {})'.format(type(self).__name__,
                                       self.start, self.stop, self.num)
    def __eq__(self, other):
        if not isinstance(other, linspace):
            return False
        return ((self.start, self.stop, self.num) ==
                (other.start, other.stop, other.num))
    def __ne__(self, other):
        return not self==other
    def __hash__(self):
        return hash((type(self), self.start, self.stop, self.num))

2

要解决浮动精度问题,可以使用Decimalmodule

这就要求转化为额外的努力,Decimalint或者float一边写代码,但你能传递str和修改功能,如果那样的便利性确实是必要的。

from decimal import Decimal
from decimal import Decimal as D


def decimal_range(*args):

    zero, one = Decimal('0'), Decimal('1')

    if len(args) == 1:
        start, stop, step = zero, args[0], one
    elif len(args) == 2:
        start, stop, step = args + (one,)
    elif len(args) == 3:
        start, stop, step = args
    else:
        raise ValueError('Expected 1 or 2 arguments, got %s' % len(args))

    if not all([type(arg) == Decimal for arg in (start, stop, step)]):
        raise ValueError('Arguments must be passed as <type: Decimal>')

    # neglect bad cases
    if (start == stop) or (start > stop and step >= zero) or \
                          (start < stop and step <= zero):
        return []

    current = start
    while abs(current) < abs(stop):
        yield current
        current += step

样本输出-

list(decimal_range(D('2')))
# [Decimal('0'), Decimal('1')]
list(decimal_range(D('2'), D('4.5')))
# [Decimal('2'), Decimal('3'), Decimal('4')]
list(decimal_range(D('2'), D('4.5'), D('0.5')))
# [Decimal('2'), Decimal('2.5'), Decimal('3.0'), Decimal('3.5'), Decimal('4.0')]
list(decimal_range(D('2'), D('4.5'), D('-0.5')))
# []
list(decimal_range(D('2'), D('-4.5'), D('-0.5')))
# [Decimal('2'),
#  Decimal('1.5'),
#  Decimal('1.0'),
#  Decimal('0.5'),
#  Decimal('0.0'),
#  Decimal('-0.5'),
#  Decimal('-1.0'),
#  Decimal('-1.5'),
#  Decimal('-2.0'),
#  Decimal('-2.5'),
#  Decimal('-3.0'),
#  Decimal('-3.5'),
#  Decimal('-4.0')]

2
使用类似的Decimal输入,np.arange工作原理相同:np.arange(Decimal('-2.0'), Decimal('2.0'), Decimal('0.1'))
hpaulj

2
是的,谢谢。虽然,这将需要一个外部(numpy)库。
shad0w_wa1k3r 18-4-24

1

添加自动更正,以防止出现错误的登录步骤:

def frange(start,step,stop):
    step *= 2*((stop>start)^(step<0))-1
    return [start+i*step for i in range(int((stop-start)/step))]

1

我的解决方案:

def seq(start, stop, step=1, digit=0):
    x = float(start)
    v = []
    while x <= stop:
        v.append(round(x,digit))
        x += step
    return v

1

最佳解决方案:无舍入错误
_________________________________________________________________________________

>>> step = .1
>>> N = 10     # number of data points
>>> [ x / pow(step, -1) for x in range(0, N + 1) ]

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]

_________________________________________________________________________________

或者,对于设定范围而不是设定数据点(例如,连续功能),请使用:

>>> step = .1
>>> rnge = 1     # NOTE range = 1, i.e. span of data points
>>> N = int(rnge / step
>>> [ x / pow(step,-1) for x in range(0, N + 1) ]

[0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]

要实现一个功能:更换x / pow(step, -1)f( x / pow(step, -1) ),并定义f
例如:

>>> import math
>>> def f(x):
        return math.sin(x)

>>> step = .1
>>> rnge = 1     # NOTE range = 1, i.e. span of data points
>>> N = int(rnge / step)
>>> [ f( x / pow(step,-1) ) for x in range(0, N + 1) ]

[0.0, 0.09983341664682815, 0.19866933079506122, 0.29552020666133955, 0.3894183423086505, 
 0.479425538604203, 0.5646424733950354, 0.644217687237691, 0.7173560908995228,
 0.7833269096274834, 0.8414709848078965]

1

start和stop具有包容性,而不是一个或另一个(通常不包括stop),并且没有导入,并且使用生成器

def rangef(start, stop, step, fround=5):
    """
    Yields sequence of numbers from start (inclusive) to stop (inclusive)
    by step (increment) with rounding set to n digits.

    :param start: start of sequence
    :param stop: end of sequence
    :param step: int or float increment (e.g. 1 or 0.001)
    :param fround: float rounding, n decimal places
    :return:
    """
    try:
        i = 0
        while stop >= start and step > 0:
            if i==0:
                yield start
            elif start >= stop:
                yield stop
            elif start < stop:
                if start == 0:
                    yield 0
                if start != 0:
                    yield start
            i += 1
            start += step
            start = round(start, fround)
        else:
            pass
    except TypeError as e:
        yield "type-error({})".format(e)
    else:
        pass


# passing
print(list(rangef(-100.0,10.0,1)))
print(list(rangef(-100,0,0.5)))
print(list(rangef(-1,1,0.2)))
print(list(rangef(-1,1,0.1)))
print(list(rangef(-1,1,0.05)))
print(list(rangef(-1,1,0.02)))
print(list(rangef(-1,1,0.01)))
print(list(rangef(-1,1,0.005)))
# failing: type-error:
print(list(rangef("1","10","1")))
print(list(rangef(1,10,"1")))

Python 3.6.2(v3.6.2:5fd33b5,2017年7月8日,04:57:36)[MSC v.1900 64位(AMD64)]


1

我知道我在这里参加聚会迟到了,但这是一个在3.6中运行的简单生成器解决方案:

def floatRange(*args):
    start, step = 0, 1
    if len(args) == 1:
        stop = args[0]
    elif len(args) == 2:
        start, stop = args[0], args[1]
    elif len(args) == 3:
        start, stop, step = args[0], args[1], args[2]
    else:
        raise TypeError("floatRange accepts 1, 2, or 3 arguments. ({0} given)".format(len(args)))
    for num in start, step, stop:
        if not isinstance(num, (int, float)):
            raise TypeError("floatRange only accepts float and integer arguments. ({0} : {1} given)".format(type(num), str(num)))
    for x in range(int((stop-start)/step)):
        yield start + (x * step)
    return

那么您可以像原始邮件一样调用它range()……没有错误处理,但是请让我知道是否有可以合理捕获的错误,我将进行更新。或者您可以更新它。这是StackOverflow。


0

这是我的解决方案,它与float_range(-1,0,0.01)一起正常工作,并且没有浮点表示错误。它不是很快,但是可以正常工作:

from decimal import Decimal

def get_multiplier(_from, _to, step):
    digits = []
    for number in [_from, _to, step]:
        pre = Decimal(str(number)) % 1
        digit = len(str(pre)) - 2
        digits.append(digit)
    max_digits = max(digits)
    return float(10 ** (max_digits))


def float_range(_from, _to, step, include=False):
    """Generates a range list of floating point values over the Range [start, stop]
       with step size step
       include=True - allows to include right value to if possible
       !! Works fine with floating point representation !!
    """
    mult = get_multiplier(_from, _to, step)
    # print mult
    int_from = int(round(_from * mult))
    int_to = int(round(_to * mult))
    int_step = int(round(step * mult))
    # print int_from,int_to,int_step
    if include:
        result = range(int_from, int_to + int_step, int_step)
        result = [r for r in result if r <= int_to]
    else:
        result = range(int_from, int_to, int_step)
    # print result
    float_result = [r / mult for r in result]
    return float_result


print float_range(-1, 0, 0.01,include=False)

assert float_range(1.01, 2.06, 5.05 % 1, True) ==\
[1.01, 1.06, 1.11, 1.16, 1.21, 1.26, 1.31, 1.36, 1.41, 1.46, 1.51, 1.56, 1.61, 1.66, 1.71, 1.76, 1.81, 1.86, 1.91, 1.96, 2.01, 2.06]

assert float_range(1.01, 2.06, 5.05 % 1, False)==\
[1.01, 1.06, 1.11, 1.16, 1.21, 1.26, 1.31, 1.36, 1.41, 1.46, 1.51, 1.56, 1.61, 1.66, 1.71, 1.76, 1.81, 1.86, 1.91, 1.96, 2.01]

0

我只是一个初学者,但是在模拟一些计算时遇到了同样的问题。这是我尝试解决的方法,似乎正在使用小数步。

我也很懒,因此我很难编写自己的范围函数。

基本上,我所做的是将我更改xrange(0.0, 1.0, 0.01)xrange(0, 100, 1)100.0在循环内使用除法。我也很担心是否会出现四舍五入的错误。所以我决定测试是否有。现在,我听说,如果例如0.01从计算中得出的浮点数不完全相同,0.01则应将它们返回False(如果我错了,请告诉我)。

因此,我决定通过运行简短的测试来测试我的解决方案是否适合我的范围:

for d100 in xrange(0, 100, 1):
    d = d100 / 100.0
    fl = float("0.00"[:4 - len(str(d100))] + str(d100))
    print d, "=", fl , d == fl

并且每个都打印True。

现在,如果我完全错了,请告诉我。


0

这个衬里不会使您的代码混乱。step参数的符号很重要。

def frange(start, stop, step):
    return [x*step+start for x in range(0,round(abs((stop-start)/step)+0.5001),
        int((stop-start)/step<0)*-2+1)]
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.