我如何在0和1之间迭代0.1步?

这表示step参数不能为零:

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

当前回答

令人惊讶的是,在Python 3文档中还没有人提到推荐的解决方案:

参见: linspace菜谱展示了如何实现适用于浮点应用程序的惰性版本的range。

一旦定义,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))

其他回答

法兰(开始、停止、精度)

def frange(a,b,i):
    p = 10**i
    sr = a*p
    er = (b*p) + 1
    p = float(p)
    return map(lambda x: x/p, xrange(sr,er))

In >frange(-1,1,1)

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

避免四舍五入问题的技巧是使用一个单独的数字在范围内移动,该数字在开始前半步开始。

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

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

这个工具也适用于十进制和分数。

这里的许多解决方案在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

在步骤中添加可能出现错误符号的自动更正:

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