如何为 range() 使用小数步长值？答案

【问题标题】：How do I use a decimal step value for range()?如何为 range() 使用小数步长值？
【发布时间】：2022-07-17 12:39:10
【问题描述】：

如何以 0.1 的步长在 0 和 1 之间进行迭代？

这表示 step 参数不能为零：

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

int(0.1) == 0，因此步长实际上为零。这可能是出乎意料的，但它是零。您可能想重申您的问题以反映您没想到这一事实。说“它不是”是错误的和误导性的。
顺便说一句，可以使用itertools.takewhile 和itertools.count 卷起一个短的单行。不过，它的性能并不比drange 好。
令人尴尬的是，python 的范围不允许这样做，因为即使没有累积舍入误差，实现生成器也很容易做到这一点。哎呀，即使是 GNU coreutils 中的 seq 工具也允许在没有舍入错误的情况下执行 seq 0 0.1 1！
@josch：seq 在内部使用 C long double 类型，并且是受到舍入误差。例如，在我的机器上，seq 0 0.1 1 将1 作为其最后一个输出（如预期的那样），但seq 1 0.1 2 将1.9 作为最后一个输出（而不是预期的2）。
为方便起见，@Kos 的建议可以实现为itertools.takewhile(lambda x: (x+0.05)<1, itertools.count(0,0.1)) 或itertools.islice(itertools.count(0,0.1), 10)（在你有import itertools 之后），虽然我没有测试过哪个更有效

标签： python floating-point range

【解决方案1】：

与其直接使用小数步长，不如用你想要的点数来表达这一点要安全得多。否则，浮点舍入错误很可能会给你一个错误的结果。

使用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])

【讨论】：

numpy 是 python 的一个无处不在的组件，我认为这个答案是最“pythonic”的。
@AndreTerra 问题是 @numpy@ 是第三方包，在依赖管理、存储（对于包本身）等方面增加了很多开销。根据开发人员的工作，可能无法使用它。
请原谅我，但由于np.linspace(1.,1.3,4) 和np.arange(1.,1.3,0.1) 给出完全相同的输出，所以我不理解最后一部分的浮点舍入错误
@deadcode 原因是 np.arange 被定义为产生一个范围 [start,stop)（即不包括 stop），所以人们不会期望 1.3 包含在列表中。请参阅this question 了解为什么仍然包含它以及如何处理它。
一个包被使用了多少可以说不是它是否是“Pythonic”的任何指标。

【解决方案2】：

range() 只能做整数，不能做浮点。

请改用list comprehension 来获取步骤列表：

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

更一般地说，generator 理解最小化内存分配：

xs = (x * 0.1 for x in range(0, 10))
for x in xs:
    print(x)

【讨论】：

更好的是，如果您使用的是 Python 2.4+，则可以只使用生成器理解。 (x * 0.1 for x in range(0, 10))。
甚至更好的是，用x/10 而不是x * 0.1 :D 实际上没什么特别的，但是里面的一些数字会更精确，例如对于3*0.1，您将获得0.30000000000000004，而对于3/10，您将获得0.3 :)
3/10 给我 0，而不是 0.3。 3/10.0 给出 0.29999999999999999。蟒蛇 2.6。
@LarsWirzenius：在 Python 2.2+ 中，from __future__ import division; 3/10 返回 0.3。此行为是 Python 3.x 中的默认行为。
也可以使用 round 函数 lst = [round(x* 0.10,2) for x in range(0,10)]

【解决方案3】：

在'xrange([start], stop[, step])' 的基础上，您可以定义一个生成器来接受和生成您选择的任何类型（坚持支持+ 和< 的类型）：

>>> 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']
>>>

【讨论】：

这有舍入问题。请看这里：code.activestate.com/recipes/66472
我会用 a （当 r > stop）和相应的 r -= step 将它扩展到另一个方向，以给出相反的方向。
我做了一个没有上述浮点精度问题的 xfrange 函数。看看 ;) stackoverflow.com/questions/477486/…
您正在累积舍入错误。请改用这个：` i = 0; r = start while r < stop: i += 1; r = 开始 + i * 步；产量 r`
这是来自pythoncentral.io/pythons-range-function-explained（和其他 Python 文档来源）

【解决方案4】：

为循环增加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() 对整数起作用，在这种情况下，这将是唯一的解决方案，至少使用相同的函数。
@cmsjr creative :D 只是一件小事：如果您使用的是 Python 2.x，则除以 100.0 以防止 Python 截断结果。我认为在 3.0 中，它会按照您的编码工作。
for i * 100 in range(0, 100, 10)：语法错误：无法分配给操作员

【解决方案5】：

我认为 NumPy 有点矫枉过正。

[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 在我测试时产生的圆角噪音较小）。

【讨论】：

最干净的解决方案imo。列表理解也使它看起来非常简短。

【解决方案6】：

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

from scipy import arange

【讨论】：

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

【解决方案7】：

与R'sseq 函数类似，这个函数返回一个序列，在给定正确的步长值的情况下以任意顺序。最后一个值等于停止值。

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 ]

【讨论】：

对于想要获得它而又不想过多使用 python 的人来说，这是一个很好的答案。
那是几乎我在寻找什么 - 请注意 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 不要这样做！如果使用floor，seq(0.2, 0.9, 0.1) 将无法到达正确的端点并返回[0.2, 0.30000000000000004, 0.4, 0.5, 0.6000000000000001, 0.7, 0.8]
@user502144：很好，谢谢。我想我必须满足于一种更复杂的解决方案才能使其保持通用性。

【解决方案8】：

range() 内置函数返回一个整数值序列，恐怕，所以你不能用它来做一个小数步。

我想说只使用一个while循环：

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

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

【讨论】：

不要这样做！添加.1 10 次与添加1 不一样！ docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html

【解决方案9】：

这是使用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）

【解决方案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]

【讨论】：

【解决方案11】：

import numpy as np
for i in np.arange(0, 1, 0.1): 
    print i

【讨论】：

这有舍入问题，引用：“当使用非整数步长时，例如 0.1，结果通常会不一致。” --docs.scipy.org/doc/numpy/reference/generated/numpy.arange.html

【解决方案12】：

如果您经常这样做，您可能希望保存生成的列表r

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

【讨论】：

【解决方案13】：

more_itertools 是实现numeric_range 工具的第三方库：

import more_itertools as mit


for x in mit.numeric_range(0, 1, 0.1):
    print("{:.1f}".format(x))

输出

0.0
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9

此工具也适用于Decimal 和Fraction。

【讨论】：

【解决方案14】：

最佳解决方案：无舍入误差

>>> 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]

【讨论】：

【解决方案15】：

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

它与 range/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)) # []

【讨论】：

如果停止是None，frange 如何工作？那部分代码甚至不再考虑步长。
@josch range 有两个签名：range(stop)，假定默认 start=0, step=1 和 range(start, stop, step)，不做任何假设。 frange 反映了这一点。当使用range(stop) 签名时，frange 和drange 都从 0 开始并以 1 递增，因此它们的行为与常规的 range(stop) 行为相同，并且停止四舍五入到最接近的整数。

【解决方案16】：

这里的许多解决方案在 Python 3.6 中仍然存在浮点错误，并且没有完全满足我个人的需要。

下面的函数采用整数或浮点数，不需要导入并且不返回浮点错误。

def frange(x, y, step):
    if int(x + y + step) == (x + y + step):
        r = list(range(int(x), int(y), int(step)))
    else:
        f = 10 ** (len(str(step)) - str(step).find('.') - 1)
        rf = list(range(int(x * f), int(y * f), int(step * f)))
        r = [i / f for i in rf]

    return r

【讨论】：

v3.9的不错的解决方案。缺乏进口是好事。干杯
如果希望输出列表包含整个范围，请更改为 rf = list(range(int(x * f), int((y+step) * f), int(step * f)))
这太好了，除非你可以制作frange(end, start=0, step=1)，它的工作方式类似于range

【解决方案17】：

很惊讶还没有人提到推荐的解决方案in the Python 3 docs：

也可以看看：

linspace recipe 展示了如何实现适用于浮点应用程序的惰性范围版本。

一旦定义，配方很容易使用，不需要numpy 或任何其他外部库，但需要numpy.linspace() 之类的函数。请注意，第三个num 参数不是step 参数，而是指定所需值的数量，例如：

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))

【讨论】：

【解决方案18】：

这是我通过浮动步骤获得范围的解决方案。
使用此功能无需导入 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 步内，则会出现错误。即 xfrange(1,10,2) 只做 1,3,5,7，缺少 9
供参考和其他读者参考，请将此实现与此stackoverflow.com/a/477610/54964 进行比较。这似乎没有大的浮动问题。
@carlosvega 你能确认一下为什么 Lobe 会得到他的结果吗？

【解决方案19】：

为了精品店的完整性，一个功能性的解决方案：

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)

【讨论】：

【解决方案20】：

您可以使用此功能：

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]
@ShaiColeman 这是一般的浮点舍入，不是这种特定方法的缺陷。如果您担心这一点，这里的几个答案包含解决方法；也可以看看stackoverflow.com/questions/588004/…
@tripleee，即使忽略舍入错误也是错误的。预期：[99.8, 99.9, 100.0] 实际：[99.7, 99.8, 99.9]

【解决方案21】：

可以使用 Numpy 库来完成。 arange() 函数允许浮动步长。但是，它返回一个 numpy 数组，为方便起见，可以使用 tolist() 将其转换为列表。

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

【讨论】：

【解决方案22】：

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）]

【讨论】：

【解决方案23】：

我知道我在这里聚会迟到了，但这是一个在 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。

【讨论】：

作为警告，此解决方案没有实现 __contains__ 运算符，并且根据您的用例，调用 if x in list(floatRange(a,b,c)):... 可能非常慢

【解决方案24】：

要解决浮点精度问题，您可以使用Decimal module。

这需要在编写代码时从int 或float 转换为Decimal 的额外努力，但如果确实需要这种便利，您可以改为传递str 并修改函数。

from decimal import Decimal


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

样本输出 -

from decimal import Decimal as D

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')]

【讨论】：

使用类似的Decimal 输入，np.arange 的工作方式相同：np.arange(Decimal('-2.0'), Decimal('2.0'), Decimal('0.1'))
是的，谢谢。虽然，这需要一个外部（numpy）库。
如果您能提供反馈或拒绝投票的理由，我将不胜感激。
关于否决票的问题毫无意义，因为没有通知选民，而且很少看到他们。我是根据 2 年前的评论收到通知的。
抱歉 ping 你，希望它不会因为我没有标记。是的，我的评论只是充满希望。

【解决方案25】：

添加自动更正以防止错误登录步骤的可能性：

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

【讨论】：

【解决方案26】：

我的解决方案：

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

【讨论】：

【解决方案27】：

这是我的解决方案，它适用于 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]

【讨论】：

【解决方案28】：

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

我也很懒，所以我发现很难编写自己的范围函数。

基本上我所做的是将我的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 。

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

【讨论】：

【解决方案29】：

避免的诀窍舍入问题是使用一个单独的数字来移动范围，即开始和一半这步在之前开始.

# 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。

【讨论】：

【解决方案30】：

我的回答与使用 map() 的其他人类似，不需要 NumPy，也不需要使用 lambda（尽管你可以）。要以 dt 为步长获取从 0.0 到 t_max 的浮点值列表：

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

【讨论】：