f = lambda x,y,z: (x+i*z for i in range(int((y-x)/z)))

上面不需要借助任何库就可以做分数步。

Range()只能处理整数，不能处理浮点数。

使用一个列表推导式来获得一个步骤列表:

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

更一般地说，生成器理解最小化内存分配:

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

令人惊讶的是，在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))

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

下面是一个使用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)

我只是一个初学者，但我有同样的问题，当模拟一些计算。这是我如何试图解决这个问题，这似乎是工作与十进制步骤。

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

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

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