有没有办法介于0和1之间0.1？
我以为我可以像下面这样做，但它失败了：
for i in range(0, 1, 0.1):
print i
相反，它表示步骤参数不能为零，这是我没想到的。
答案 0 :(得分：761)
不是直接使用小数步骤，而是根据您想要的点数来表达它更安全。否则，浮点舍入错误可能会给您一个错误的结果。
您可以使用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])
答案 1 :(得分：186)
Python的range（）只能做整数，而不是浮点数。在您的特定情况下，您可以使用列表推导：
[x * 0.1 for x in range(0, 10)]
（将调用替换为该表达式的范围。）
对于更一般的情况，您可能想要编写自定义函数或生成器。
答案 2 :(得分：143)
在'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']
>>>
答案 3 :(得分：31)
增加循环的i幅度，然后在需要时减少它。
for i * 100 in range(0, 100, 10):
print i / 100.0
编辑：我真的不记得为什么我认为这会在语法上有效
for i in range(0, 11, 1):
print i / 10.0
那应该有所需的输出。
答案 4 :(得分：23)
scipy有一个内置函数arange，它概括了Python的range()构造函数，以满足您对浮点处理的要求。
from scipy import arange
答案 5 :(得分：22)
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在我测试时产生的舍入噪音更小。）
答案 6 :(得分：16)
与R's 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]
答案 7 :(得分：12)
range（）内置函数返回一个整数值序列，我担心，所以你不能用它来做一个小数步。
我想说只需使用while循环：
i = 0.0
while i <= 1.0:
print i
i += 0.1
如果你很好奇，Python会将你的0.1转换为0，这就是为什么它告诉你参数不能为零。
答案 8 :(得分：11)
以下是使用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)
答案 9 :(得分：9)
[x * 0.1 for x in range(0, 10)]
为您提供了以下结果：
[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]
答案 10 :(得分：8)
import numpy as np
for i in np.arange(0, 1, 0.1):
print i
答案 11 :(得分：5)
如果您经常这样做，您可能希望保存生成的列表r
r=map(lambda x: x/10.0,range(0,10))
for i in r:
print i
答案 12 :(得分：4)
我的版本使用原始范围函数为移位创建乘法索引。这允许与原始范围函数相同的语法。 我有两个版本，一个使用float，一个使用Decimal，因为我发现在某些情况下我想避免浮点运算引入的舍入漂移。
与范围/ xrange中的空集结果一致。
只将一个数值传递给任一函数会将标准范围输出返回到输入参数的整数上限值（因此，如果给它5.5，它将返回范围（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)) # []
答案 13 :(得分：4)
这是我使用浮动步骤获取范围的解决方案。
使用此功能，无需导入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]
答案 14 :(得分：3)
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
答案 15 :(得分：2)
您可以使用此功能：
def frange(start,end,step):
return map(lambda x: x*step, range(int(start*1./step),int(end*1./step)))
答案 16 :(得分：2)
我的回答类似于其他人使用map（），不需要NumPy，也没有使用lambda（尽管你可以）。要以dt：
的步长获得从0.0到t_max的浮点值列表def xdt(n):
return dt*float(n)
tlist = map(xdt, range(int(t_max/dt)+1))
答案 17 :(得分：2)
避免舍入问题的诀窍是使用单独的数字来移动范围，然后开始一半 步骤在开始之前。
# 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。
答案 18 :(得分：2)
为了完整的精品店，一个功能性的解决方案：
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)
答案 19 :(得分：2)
可以使用Numpy库完成。 arange（）函数允许float中的步骤。但是，为了方便起见，它返回一个numpy数组，可以使用tolist（）转换为list。
for i in np.arange(0, 1, 0.1).tolist():
print i
答案 20 :(得分：1)
惊讶没有人提到推荐的解决方案in the Python 3 docs：
另见：
- linspace recipe显示了如何实现适合浮点应用程序的惰性范围。
一旦定义，该配方易于使用，不需要numpy或任何其他外部库，但需要numpy.linspace()等功能。请注意，第三个step参数不是num参数，而是指定所需值的数量，例如：
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))
答案 21 :(得分：1)
启动和停止是包容性的而不是一个或另一个（通常是停止排除）并且没有导入和使用生成器
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）]
答案 22 :(得分：1)
最佳解决方案：没有舍入错误
的 _________________________________________________________________________________
>>> 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]
答案 23 :(得分：1)
要解决浮动精度问题，可以使用Decimal module。
这需要在编写代码时从Decimal或int转换为float，但您可以通过str并修改该函数方便的确是必要的。
from decimal import Decimal
from decimal import Decimal as D
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
示例输出 -
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')]
答案 24 :(得分：1)
我的解决方案：
def seq(start, stop, step=1, digit=0):
x = float(start)
v = []
while x <= stop:
v.append(round(x,digit))
x += step
return v
答案 25 :(得分：1)
添加自动更正以查找步骤中错误签名的可能性：
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 :(得分：0)
sign = lambda x: (1, -1)[x < 0]
def frange(start, stop, step):
i = 0
r=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 += 1
else:
while start + i * step > stop:
yield round(start + i * step,r)
i += 1
答案 27 :(得分：0)
许多解决方案在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
答案 28 :(得分：0)
我知道我在这里参加聚会迟到了，但这是一个在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。
答案 29 :(得分：0)
frange（开始，停止，精确）
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]
答案 30 :(得分：0)
这一个班轮不会使你的代码混乱。 步骤参数的符号非常重要。
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)]
答案 31 :(得分：0)
我只是初学者，但在模拟某些计算时遇到了同样的问题。以下是我尝试解决这个问题的方法，这似乎与十进制步骤有关。
我也很懒，所以我发现写自己的范围功能很难。
基本上我所做的是将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。
现在，如果我完全错了，请告诉我。
答案 32 :(得分：0)
这是我的解决方案，它与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]