如何在range()函数中使用小数步长值？

Question

如何在range()函数中使用小数步长值？

1005

如何通过0.1的步长在0和1之间进行迭代？

这说明步长参数不能为零：

for i in range(0, 1, 0.1):
    print(i)

- Evan Fosmark

21

int(0.1) 等于 0，因此步长实际上是零。这可能令人意外，但确实是零。你可能需要重新阐述你的问题来反映这个事实，说“不是”的话是错误和误导的。 - S.Lott

3

顺便说一句，可以使用itertools.takewhile和itertools.count来编写一个简短的一行代码。尽管性能不如drange。 - Kos

4

考虑到即使不累计舍入误差，实现一个生成器也很容易，Python 的 range 不允许这样做，这真是令人尴尬。唉，就连 GNU coreutils 中的 seq 工具也可以避免舍入误差地执行 seq 0 0.1 1！ - josch

3

seq 在内部使用 C 语言的 long double 类型，因此可能会出现舍入误差。例如在我的电脑上，seq 0 0.1 1 的最后一个输出为 1（如预期），但 seq 1 0.1 2 的最后一个输出为 1.9（而不是预期的 2）。 - Mark Dickinson

1

为方便起见，@Kos的建议可以实现为itertools.takewhile(lambda x: (x+0.05)<1, itertools.count(0,0.1)) 或 itertools.islice(itertools.count(0,0.1), 10)（在你有import itertools之后），不过我还没有测试哪种更有效。 - LHeng

这就是为什么Python和JavaScript被称作玩具语言的原因... - gdm

34个回答

295

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)

- user25148

41

如果你使用的是 Python 2.4+，那么更好的方法是使用生成器推导式：(x * 0.1 for x in range(0, 10))。 - JAB

65

更好的做法是使用x/10代替x*0.1 :D 实际上并没有什么特别之处，但其中一些数字会更精确，例如 3*0.1 会得到 0.30000000000000004 ，而使用3/10则可以得到 0.3 :) - Bloke

6

3/10给我0，而不是0.3。3/10.0给出的结果是0.29999999999999999，在Python 2.6版本中。 - user25148

25

在Python 2.2+中，使用from __future__ import division; 3/10语句将返回0.3。在Python 3.x中，默认情况下也是如此。 - Benjamin Hodgson

3

round函数也可以用来做这件事：lst = [round(x* 0.10,2) for x in range(0,10)]。 - MARK

显示剩余3条评论

158

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

- gimel

51

这会存在舍入误差问题。请查看这里：http://code.activestate.com/recipes/66472/ - Christian Oudard

我会稍微扩展一下，为了给另一个方向加上 (while r > stop) 和相应的 r -= step 以便给出相反的方向。 - user318904

你的代码为：

l=frange(0,1,0.1)
print l

输出结果为： [0.0, 0.1, 0.2, 0.30000000000000004, 0.4, 0.5, 0.6000000000000001, 0.7000000000000001, 0.8, 0.9]但是使用Numpy时，结果为： [ 0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9] - andilabs

1

我编写了一个xfrange函数，解决了上述浮点精度问题。来看看吧 ;) https://dev59.com/oHRB5IYBdhLWcg3w4bKv#20549652 - Carlos Vega

1

你正在累积舍入误差。请改用以下代码：i = 0; r = start while r < stop: i += 1; r = start + i * step; yield r - Cees Timmerman

1

这段内容来自https://www.pythoncentral.io/pythons-range-function-explained/（以及其他Python文档来源） - Apostolos

37

增加循环中的大小，需要时再减小。

for i * 100 in range(0, 100, 10):
    print i / 100.0

编辑：老实说，我真的不记得我为什么认为那样在语法上会起作用了。

for i in range(0, 11, 1):
    print i / 10.0

那应该会得到期望的输出。

- cmsjr

1

我认为你会发现range()函数只适用于整数，因此这将是唯一的解决方案，至少要使用相同的函数。 - Matthew Scharley

2

@cmsjr 创意十足 :D 只有一个小问题：除以100.0，这样可以防止在使用Python 2.x时截断结果。我认为在3.0版本中，你编码的方式将起作用。 - Dana

5

for i * 100 in range(0, 100, 10): 语法错误：无法将值赋给运算符。 - Anne van Rossum

36

我认为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 产生的舍入误差较少。）

- Kalle

1

在我看来，这是最干净的解决方案。列表推导式也使它看起来非常简短和简单。 - Telso

24

scipy内置了一个名为arange的函数，它是对Python的range()构造器的推广，以满足您处理浮点数的需求。

from scipy import arange

- Catherine Ray

14

这实际上是在numpy中可以找到的完全相同的arange函数：`>>> import scipy

import numpy >>> numpy.arange is scipy.arange 将返回True`。

- iFreilicht

21

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

- zeferino

2

这是一个很好的答案，适合那些想要了解Python但不想深入学习的人。 - Chani

1

那差不多是我要找的 - 请注意，seq(0.5, 3.0) 返回 [0.5, 1.5, 2.5, 3.5]。为了避免最后一个条目超出范围，请将 n = int(round(... 替换为 n = int(floor(... 并在顶部（def seq(... 上面）添加行 from math import floor。 - FriendFX

3

不要这样做！如果使用“floor”函数，”seq(0.2, 0.9, 0.1)”将无法到达右端点，并返回“[0.2, 0.30000000000000004, 0.4, 0.5, 0.6000000000000001, 0.7, 0.8]”。 - fdermishin

@user502144：好发现，谢谢。我想我必须选择更复杂的解决方案来保持通用性。 - FriendFX

17

range() 函数返回整数值序列，所以无法使用它进行小数步长。我建议使用 while 循环：

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

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

- Dana

3

不要这样做！将“.1”加十次并不等同于加“1”！https://docs.oracle.com/cd/E19957-01/806-3568/ncg_goldberg.html - cat

15

以下是使用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)

- Pramod

为了完整起见，您应该计算sample_count变量的绝对值，这样您的函数也可以用于负数起始（即从-10到10）。 - Deleteman

12

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

- Nik

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Andrew Jaffe · Accepted Answer

不要直接使用十进制步长，最好以您希望获得的点数来表达。否则，浮点舍入误差可能会给您带来错误的结果。

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