这是我的解决方案，以获得浮动步长范围。 使用这个函数，不需要导入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]

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

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

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

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

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

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

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)