如何为range（）使用十进制步长值？

增加循环的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（）返回一系列整数值，恐怕，所以你不能用它来做小数步。

我想说只使用一个这时循环：

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

如果你好奇，Python正在将0.1转换为0，这就是为什么它告诉你参数不能为零。

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)

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

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

在'xrange（[开始]，停止[，步骤]）'的基础上，您可以定义一个生成器来接受和生成您选择的任何类型（坚持支持+和<的类型）：

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

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

使用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产生一个长度为4的数组，而它应该只产生3个数字：

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

您可以使用此功能：

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

添加自动更正步骤上不正确签名的可能性：

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

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

类似于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]

我的解决方案：

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

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

以下是使用迭代工具的解决方案：

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)

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

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

仅向任一函数传递单个数值将返回标准范围输出到输入参数的整数上限值（因此如果您给它5.5，它将返回范围（6）。）

编辑：下面的代码现在可以在pypi上作为包使用：

## frange.pyfrom math import ceil# find best range function available to version (2.7.x / 3.x.x)try:_xrange = xrangeexcept NameError:_xrange = range
def frange(start, stop = None, step = 1):"""frange generates a set of floating point values over therange [start, stop) with step size step
frange([start,] stop [, step ])"""
if stop is None:for x in _xrange(int(ceil(start))):yield xelse:# create a generator expression for the index valuesindices = (i for i in _xrange(0, int((stop-start)/step)))# yield resultsfor i in indices:yield start + step*i
## drange.pyimport decimalfrom math import ceil# find best range function available to version (2.7.x / 3.x.x)try:_xrange = xrangeexcept NameError:_xrange = range
def drange(start, stop = None, step = 1, precision = None):"""drange generates a set of Decimal values over therange [start, stop) with step size step
drange([start,] stop, [step [,precision]])"""
if stop is None:for x in _xrange(int(ceil(start))):yield xelse:# find precisionif precision is not None:decimal.getcontext().prec = precision# convert values to decimalsstart = decimal.Decimal(start)stop = decimal.Decimal(stop)step = decimal.Decimal(step)# create a generator expression for the index valuesindices = (i for i in _xrange(0,((stop-start)/step).to_integral_value()))# yield resultsfor i in indices:yield float(start + step*i)
## testranges.pyimport frangeimport drangelist(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)) # []

这是我的解决方案，它可以很好地处理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)) % 1digit = len(str(pre)) - 2digits.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 stepinclude=True - allows to include right value to if possible!! Works fine with floating point representation !!"""mult = get_multiplier(_from, _to, step)# print multint_from = int(round(_from * mult))int_to = int(round(_to * mult))int_step = int(round(step * mult))# print int_from,int_to,int_stepif 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 resultfloat_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]

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

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

基本上我所做的就是将我的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.0fl = float("0.00"[:4 - len(str(d100))] + str(d100))print d, "=", fl , d == fl

它为每个人打印了True。

现在，如果我完全弄错了，请让我知道。

这一行不会弄乱您的代码。步骤参数的符号很重要。

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

这是我用浮点步骤获取范围的解决方案。
使用这个函数，不需要导入numpy，也不需要安装它。
我很确定它可以改进和优化。随意做，并在这里发布。

from __future__ import divisionfrom math import log
def xfrange(start, stop, step):
old_start = start #backup this value
digits = int(round(log(10000, 10)))+1 #get number of digitsmagnitude = 10**digitsstop = int(magnitude * stop) #convert fromstep = 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 iterationsend_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]

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

from scipy import arange

frange（启动、停止、精度）

def frange(a,b,i):p = 10**isr = a*per = (b*p) + 1p = 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 rangedef frange(a, b, stp=1.0):i = a+stp/2.0while i<b:yield aa += stpi += stp

或者，可以使用numpy.arange。

对于精品店的完整性，功能解决方案：

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)

它可以使用Numpy库来完成。arange（）函数允许浮点数中的步骤。但是，它返回一个numpy数组，为了我们的方便，可以使用tolist（）将其转换为列表。

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

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

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

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

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

我认为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=100y=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产生的舍入噪声较少）。

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

import more_itertools as mit

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

产出

0.00.10.20.30.40.50.60.70.80.9

此工具也适用于Decimal和Fraction。

开始和停止是包含的，而不是一个或另一个（通常不包括停止），并且没有导入，并且使用生成器

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 = 0while stop >= start and step > 0:if i==0:yield startelif start >= stop:yield stopelif start < stop:if start == 0:yield 0if start != 0:yield starti += 1start += stepstart = round(start, fround)else:passexcept TypeError as e:yield "type-error({})".format(e)else:pass

# passingprint(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， Jul 8 2017,04:57:36）[MSC v.1900 64位（AMD64）]

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

另见：

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

定义后，配方易于使用，不需要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.abcimport 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, numself.step = (stop-start)/(num-1)def __len__(self):return self.numdef __getitem__(self, i):if isinstance(i, slice):return [self[x] for x in range(*i.indices(len(self)))]if i < 0:i = self.num + iif i >= self.num:raise IndexError('linspace object index out of range')if i == self.num-1:return self.stopreturn self.start + i*self.stepdef __repr__(self):return '{}({}, {}, {})'.format(type(self).__name__,self.start, self.stop, self.num)def __eq__(self, other):if not isinstance(other, linspace):return Falsereturn ((self.start, self.stop, self.num) ==(other.start, other.stop, other.num))def __ne__(self, other):return not self==otherdef __hash__(self):return hash((type(self), self.start, self.stop, self.num))

要解决浮点精度问题，您可以使用#0模块。

这需要在编写代码时额外努力从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], oneelif len(args) == 2:start, stop, step = args + (one,)elif len(args) == 3:start, stop, step = argselse: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 casesif (start == stop) or (start > stop and step >= zero) or \(start < stop and step <= zero):return []
current = startwhile abs(current) < abs(stop):yield currentcurrent += 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')]

sign = lambda x: (1, -1)[x < 0]def frange(start, stop, step):i = 0r=len(str(step).split('.')[-1])args=(start,stop,step)if not step :return []if all(int(i)==float(i) for i in args):start,stop,step=map(int,args)if sign(step)==1:while start + i * step < stop:yield round(start + i * step,r)i += 1else:while start + i * step > stop:yield round(start + i * step,r)i += 1

我知道我迟到了，但这里有一个在3.6中工作的微不足道的生成器解决方案：

def floatRange(*args):start, step = 0, 1if 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。

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

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

上面可以做小数步骤而不诉诸任何库。