如何通过0.1的步长在0和1之间进行迭代?
这说明步长参数不能为零:
for i in range(0, 1, 0.1):
print(i)
如何通过0.1的步长在0和1之间进行迭代?
这说明步长参数不能为零:
for i in range(0, 1, 0.1):
print(i)
import numpy as np
for i in np.arange(0, 1, 0.1):
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]
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
如果您经常这样做,您可能想保存生成的列表r
r=map(lambda x: x/10.0,range(0,10))
for i in r:
print i
我的版本使用原始的range函数创建乘法索引来进行移位,这允许与原始的range函数具有相同的语法。我创建了两个版本,一个使用float,另一个使用Decimal,因为我发现在某些情况下我想避免浮点数算术所引入的舍入误差。
它与range/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)) # []
None
,frange
函数该如何工作?代码的这一部分甚至不再考虑步长大小。 - joschrange
有两个签名:range(stop)
,它假定默认的start=0, step=1
,和range(start, stop, step)
,其中不做任何假设。frange
反映了这一点。
当使用range(stop)
签名时,frange
和drange
都从0开始递增1,因此它们的行为与常规的range(stop)
行为相同,停止时会四舍五入到最近的整数。 - Nisan.H这里有很多解决方案在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
frange(end, start=0, step=1)
,它将与 range
类似工作。 - nehem惊讶的是,还没有人提到Python 3文档中推荐的解决方案:
另请参阅:
- linspace recipe展示了如何实现适用于浮点应用程序的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]
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))
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]
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)
start和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编程语言的版本号和一些相关信息,其中包括版本号、构建日期、操作系统等。Python 3.6.2 (v3.6.2:5fd33b5, Jul 8 2017, 04:57:36) [MSC v.1900 64 bit (AMD64)]
itertools.takewhile
和itertools.count
来编写一个简短的一行代码。尽管性能不如drange
。 - Kosseq 0 0.1 1
! - joschseq
在内部使用 C 语言的long double
类型,因此可能会出现舍入误差。例如在我的电脑上,seq 0 0.1 1
的最后一个输出为1
(如预期),但seq 1 0.1 2
的最后一个输出为1.9
(而不是预期的2
)。 - Mark Dickinsonitertools.takewhile(lambda x: (x+0.05)<1, itertools.count(0,0.1))
或itertools.islice(itertools.count(0,0.1), 10)
(在你有import itertools
之后),不过我还没有测试哪种更有效。 - LHeng