有沒有辦法在0和1之間以0.1步進？
我以為我可以像下面那樣做，但是失敗了：
for i in range(0, 1, 0.1):
print i
相反，它說step參數不能為零，這是我沒有想到的。
#1樓
[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]
#2樓
與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]
#3樓
我的解決方案：
def seq(start, stop, step=1, digit=0):
x = float(start)
v = []
while x <= stop:
v.append(round(x,digit))
x += step
return v
#4樓
import numpy as np
for i in np.arange(0, 1, 0.1):
print i
#5樓
這是使用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)
#6樓
我的版本使用原始的範圍函數來為班次建立乘法索引。 這允許與原始範圍函數使用相同的文法。 我做了兩個版本，一個使用浮點，一個使用十進制，因為我發現在某些情況下我想避免浮點算術引入的舍入漂移。
它與範圍/ xrange中的空集結果一緻。
僅将單個數值傳遞給任何一個函數都将使标準範圍輸出傳回到輸入參數的整數上限值（是以，如果給定5.5，則它将傳回range（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)) # []
#7樓
這是我的解決方案，它與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]
#8樓
我隻是一個初學者，但是在模拟某些計算時遇到了同樣的問題。 這是我嘗試解決的方法，似乎正在使用小數步。
我也很懶，是以我發現很難編寫自己的範圍函數。
基本上，我所做的是将
xrange(0.0, 1.0, 0.01)
xrange(0, 100, 1)
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。
現在，如果我完全錯了，請告訴我。
#9樓
這個襯裡不會使您的代碼混亂。 step參數的符号很重要。
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)]
#10樓
這是我使用浮動步長擷取範圍的解決方案。
使用此功能，無需導入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]
#11樓
scipy
有一個内置的功能，
arange
推廣了Python的
range()
構造函數，以滿足您的浮動處理要求。
from scipy import arange
#12樓
範圍（開始，停止，精度）
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]
#13樓
您可以使用此功能：
def frange(start,end,step):
return map(lambda x: x*step, range(int(start*1./step),int(end*1./step)))
#14樓
訣竅避免四舍五入問題是使用一個單獨的号碼通過的範圍内移動，啟動和啟動的領先一步 的一半 。
# 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
。
#15樓
為了完善精品店，提供了一個實用的解決方案：
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)
#16樓
可以使用Numpy庫完成。 arange（）函數允許進行浮動操作。 但是，它傳回一個numpy數組，為友善起見，可以使用tolist（）将其轉換為list。
for i in np.arange(0, 1, 0.1).tolist():
print i
#17樓
最佳解決方案： 無舍入錯誤
_________________________________________________________________________________
>>> 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]
要實作一個功能：用
f( x / pow(step, -1) )
替換
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]
#18樓
我的答案與使用map（）的其他答案類似，不需要NumPy，也不需要使用lambda（盡管可以）。 要以dt的步長擷取從0.0到t_max的浮點值清單：
def xdt(n):
return dt*float(n)
tlist = map(xdt, range(int(t_max/dt)+1))
#19樓
我認為NumPy有點矯kill過正。
[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]
一般來說，要逐漸進行
y
1/x
運算，
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
産生的舍入噪聲較小）。
#20樓
添加自動更正，以防止出現錯誤的登入步驟：
def frange(start,step,stop):
step *= 2*((stop>start)^(step<0))-1
return [start+i*step for i in range(int((stop-start)/step))]
#21樓
為循環增加
i
的大小，然後在需要時減小
i
的大小。
for i * 100 in range(0, 100, 10):
print i / 100.0
編輯：老實說，我不記得為什麼我認為這将在文法上起作用
for i in range(0, 11, 1):
print i / 10.0
那應該具有所需的輸出。
#22樓
恐怕range（）内置函數會傳回一個整數值序列，是以您不能使用它執行小數步。
我想說的隻是使用while循環：
i = 0.0
while i <= 1.0:
print i
i += 0.1
如果您很好奇，Python會将您的0.1轉換為0，這就是為什麼它告訴您參數不能為零的原因。
#23樓
Python的range（）隻能做整數，不能做浮點數。 在您的特定情況下，可以改用清單推導：
[x * 0.1 for x in range(0, 10)]
（用該表達式将調用替換為range。）
對于更一般的情況，您可能需要編寫自定義函數或生成器。
#24樓
如果你這樣做的時候，你可能想儲存生成的清單
r
r=map(lambda x: x/10.0,range(0,10))
for i in r:
print i
#25樓
在'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']
>>>
#26樓
與直接使用小數步相比，用所需的點數表示這一點要安全得多。 否則，浮點舍入錯誤可能會給您帶來錯誤的結果。
您可以使用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])
但是，浮點舍入錯誤會引起問題。 這是一個簡單的情況，當四舍五入誤差僅會産生3個數字時，會導緻
arange
産生一個length-4數組：
>>> numpy.arange(1, 1.3, 0.1)
array([1. , 1.1, 1.2, 1.3])
#27樓
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
該工具也适用于
Decimal
和
Fraction
。
#28樓
start和stop是包含性的，而不是一個或另一個（通常不包括stop），并且沒有導入，并且使用生成器
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）]
#29樓
令人驚訝的是，沒有人在Python 3文檔中提到推薦的解決方案：
也可以看看：
- linspace配方顯示了如何實作适用于浮點應用程式的lazy版本的range。
定義後，該食譜易于使用，不需要
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))
#30樓
要解決浮點精度問題，可以使用
Decimal
子產品 。
這需要在編寫代碼時從
int
或
float
轉換為
Decimal
的額外工作，但是如果确實需要這種便利，則可以傳遞
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')]
![TestLink導出用例轉換工具(XML2Excel)[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)