Question

如何在Python中使用range()生成以下列表？

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Answer 1

使用reversed()功能：

reversed(range(10))

它更有意义。

<强>更新

如果你想让它成为一个列表（如btk指出的那样）：

list(reversed(range(10)))

更新

如果您只想使用range来获得相同的结果，则可以使用其所有参数。 range(start, stop, step)

例如，要生成列表[5,4,3,2,1,0]，您可以使用以下内容：

range(5, -1, -1)

它可能不太直观，但正如评论所提到的，这更有效，并且正确使用范围用于反向列表。

Answer 2

使用'range'内置函数。签名是range(start, stop, step)。这会产生一个产生数字的序列，从start开始，到达stop时结束，不包括stop。

>>> range(9,-1,-1)   
    [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> range(-2, 6, 2)
    [-2, 0, 2, 4]

在Python 3中，这会产生一个非列表range对象，它有效地像只读列表一样运行（但使用的内存更少，特别是对于大范围）。

Answer 3

您可以使用与range(10)[::-1]相同的range(9, -1, -1)，并且可以说更具可读性（如果您熟悉常见的sequence[::-1] Python习语）。

Answer 4

对于那些对目前收集的选项的“效率”感兴趣的人......

Jaime RGP's answer让我在计时之后重新启动我的计算机 Jason的某些“具有挑战性”的解决方案完全遵循我自己的建议（通过评论））。为了避免让你感到好奇的停机时间，我在这里展示了我的结果（最差的）：

Jason's answer（也许只是对list comprehension的力量的一次探索）：

$ python -m timeit "[9-i for i in range(10)]" 1000000 loops, best of 3: 1.54 usec per loop

martineau's answer（如果您熟悉extended slices syntax，则可读）：

$ python -m timeit "range(10)[::-1]" 1000000 loops, best of 3: 0.743 usec per loop

Michał Šrajer's answer（已接受的，非常易读）：

$ python -m timeit "reversed(range(10))" 1000000 loops, best of 3: 0.538 usec per loop

bene's answer（第一个，但非常粗略at that time）：

$ python -m timeit "range(9,-1,-1)" 1000000 loops, best of 3: 0.401 usec per loop

使用Val Neekman的range(n-1,-1,-1)表示法很容易记住最后一个选项。

Answer 5

for i in range(8, 0, -1)

会解决这个问题。它将输出8到1，-1表示反向列表

Answer 6

除了可读性之外，reversed(range(n))似乎比range(n)[::-1]更快。

$ python -m timeit "reversed(range(1000000000))"
1000000 loops, best of 3: 0.598 usec per loop
$ python -m timeit "range(1000000000)[::-1]"
1000000 loops, best of 3: 0.945 usec per loop

如果有人想知道：）

Answer 7

无法使用reverse作为范围方法可以返回反向列表。

当您对 n 项进行迭代并希望替换range(start, stop, step)返回的列表顺序时，您必须使用第三个参数来识别{{ 1}}并将其设置为step，其他参数应相应调整：

将停止参数设为-1（之前的-1值，stop - 1等于stop）。
作为开始参数使用0。

因此，相反的范围（n）将以相反的顺序排列：

n-1

Answer 8

此问题中的要求要求降序的大小为10的list整数订购。所以，让我们在python中生成一个列表。

# This meets the requirement.
# But it is a bit harder to wrap one's head around this. right?
>>> range(10-1, -1, -1)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

# let's find something that is a bit more self-explanatory. Sounds good?
# ----------------------------------------------------

# This returns a list in ascending order.
# Opposite of what the requirement called for.
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# This returns an iterator in descending order.
# Doesn't meet the requirement as it is not a list.
>>> reversed(range(10))
<listreverseiterator object at 0x10e14e090>

# This returns a list in descending order and meets the requirement
>>> list(reversed(range(10)))
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Answer 9

您可以使用范围（）BIF Like，

打印反向数字

for number in range ( 10 , 0 , -1 ) :
    print ( number )

输出将是 [10,9,8,7,6,5,4,3,2,1]

range（） - 范围（开始，结束，递增/递减）其中start是包含的，end是独占的，increment可以是任何数字，行为类似于步骤

Answer 10

经常问的一个问题是，range(9, -1, -1)是否比Python 3中的reversed(range(10))好？使用迭代器使用其他语言的人会立即想到，reversed（）必须缓存所有值，然后以相反的顺序返回。问题是，如果对象只是一个迭代器，Python的reversed()运算符将无法工作。该对象必须具有以下两项之一才能使reversed（）起作用：

通过len()支持[]和整数索引
或者已实施__reversed__()方法。

如果您尝试对没有以上任何一项的对象使用reversed（），则会得到：

>>> [reversed((x for x in range(10)))]
TypeError: 'generator' object is not reversible

因此，简而言之，Python的reversed()仅用于类似对象的数组，因此它的性能应与正向迭代相同。

但是range()呢？那不是发电机吗？在Python 3中，它是生成器，但包装在同时实现以上两者的类中。因此range(100000)不会占用大量内存，但仍支持高效的索引编制和反转。

因此，总而言之，您可以使用reversed(range(10))而不会影响性能。

Answer 11

我相信这可以提供帮助，

range(5)[::-1]

以下是用法：

for i in range(5)[::-1]:
    print i

Answer 12

我认为，很多人（对我自己）可能会对以倒序遍历现有列表的常见情况感兴趣，而不是如标题中所述，而不仅仅是为此生成索引遍历。

尽管如此，所有正确的答案在此情况下仍然都很好，我想指出的是，Wolf's answer中进行的性能比较仅用于生成索引。因此，对于以相反的顺序遍历现有列表，我已经做了类似的基准测试。

TL; DR a[::-1]最快。

注意：如果您想更详细地分析不同的冲销替代方案及其效果，请查看this great answer。

先决条件：

a = list(range(10))

Jason's answer：

%timeit [a[9-i] for i in range(10)]
1.27 µs ± 61.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

martineau's answer：

%timeit a[::-1]
135 ns ± 4.07 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

Michał Šrajer's answer：

%timeit list(reversed(a))
374 ns ± 9.87 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

bene's answer：

%timeit [a[i] for i in range(9, -1, -1)]
1.09 µs ± 11.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

如您所见，在这种情况下，无需显式生成索引，因此最快的方法是执行较少额外操作的方法。

NB：我在JupyterLab中进行了测试，它具有便捷的“魔术命令” %timeit。它在引擎盖下使用标准的timeit.timeit。经过Python 3.7.3测试

Answer 13

不使用[:: - 1]或反转使用

def reverse(text):
    result = []
    for index in range(len(text)-1,-1,-1):
        c = text[index]
        result.append(c)
    return ''.join(result)

print reverse("python!")

Answer 14

[9-i for i in range(10)]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Answer 15

您不一定需要使用范围功能，您可以简单地执行列表[:: - 1]，它应该以相反的顺序快速返回列表，而不使用任何添加。

Answer 16

range(9,-1,-1)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Answer 17

假设您有一个列表调用它一个= {1,2,3,4,5} 现在，如果您想反向打印列表，只需使用以下代码。

a.reverse
for i in a:
   print(i)

我知道你问过使用范围，但它已经回答了。

Answer 18

因为range(n)产生了可迭代的结果，所以您可以做各种美好的事情，这些都会产生您想要的结果，例如：

range(n)[::-1]

如果循环正常，我们可以排一个队列：

a = []
for i in range(n):
    a.insert(0,a)
return a

或在其上使用reverse（）方法：

reverse(range(n))

Answer 19

range(9,-1,-1)
    [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

表格是否正确。如果你使用

reversed(range(10))

你不会得到0案。例如，假设您的10不是幻数，而您用于查找的变量从反向开始。如果n的情况为0，则反向（范围（0））将不会执行，如果您偶然在零索引中有一个对象，那么这是错误的。

使用range（）以相反的顺序打印列表？

19 个答案: