用range()?

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

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

列表构造函数将range(一个python生成器)转换为列表。

使用reversed()函数:

reversed(range(10))

这更有意义。

更新:

如果你想让它是一个列表(正如btk指出的那样):

list(reversed(range(10)))

更新:

如果你只想使用range来达到相同的结果，你可以使用它的所有参数。range(start, stop, step)

例如，要生成一个列表[5,4,3,2,1,0]，可以使用以下方法:

range(5, -1, -1)

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

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

你可以使用range(10)[::-1]，它和range(9, -1, -1)是一样的，而且可以说更具可读性(如果你熟悉常见的sequence[::-1] Python习语)。

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

是正确的形式。如果你使用

reversed(range(10))

你不会得到0的情况。例如，假设你的10不是一个神奇的数字，也不是一个你用来反向查找的变量。如果你的n case是0，则反转(range(0))将不会执行，如果你碰巧在0索引中有一个对象，这是错误的。

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

不带[::-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!")

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

我相信这有帮助，

range(5)[::-1]

用法如下:

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

除了可读性，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

如果有人想知道的话:)

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

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

使用reverse没有意义，因为range函数可以返回反向列表。

当你对n项进行迭代，并想要替换由range(start, stop, step)返回的列表的顺序时，你必须使用范围的第三个参数，它标识了step并将其设置为-1，其他参数应相应调整:

1. 提供stop参数为-1(它之前的值stop - 1， stop等于0)。
2. 作为开始参数使用n-1。

因此，range(n)的倒序等价物是:

n = 10
print range(n-1,-1,-1)
#[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

你不一定需要使用range函数，你可以简单地使用list[::-1]，它应该以相反的顺序快速返回列表，而不使用任何添加。

你可以用range() BIF打印反向数字，比如，

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

输出将为 (10、9、8、7、6、5、4、3、2、1]< / p >

range() - range(开始，结束，递增/递减) 其中开始是包容性的，结束是排他的，增量可以是任何数字，行为像step

对于那些对“效率”感兴趣的人;到目前为止收集的选项中…

Jaime RGP的回答让我在时机之后找到了重启我的电脑。杰森的解决方案字面上遵循我自己的建议(通过评论)。为了避免你的好奇心停机，我在这里展示我的结果(最差的第一):^[1]

杰森的回答(可能只是对列表理解的力量的一次远足):

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

马提瑙的回答(如果你熟悉扩展片语法可读):

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

米夏拉Šrajer的回答(公认的，非常易读):

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

野猪的回答(第一个，但非常粗略的那时):

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

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

^[1]正如Karl Knechtel所评论的，这里给出的结果是依赖于版本的，并参考Python 3。X版本在回答这个问题时是稳定的。

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

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

经常被问到的问题是在python3中range(9, -1, -1)是否比reversed(range(10))更好?在其他语言中使用迭代器的人立即倾向于认为reversed()必须缓存所有值，然后以相反的顺序返回。问题是，如果对象只是一个迭代器，Python的reversed()操作符就不起作用。对象必须具有以下两个中的一个才能使reversed()工作:

1. 通过[]支持len()和整数索引
2. 或者实现__reversed__()方法。

如果你尝试在一个以上都没有的对象上使用reversed()，那么你会得到:

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

所以简而言之，Python的reversed()仅用于数组类对象，因此它应该具有与前向迭代相同的性能。

但是range()呢?那不是发电机吗?在python3中，它是生成器，但包装在实现上述两种方法的类中。所以range(100000)不会占用大量内存，但它仍然支持高效的索引和倒序。

所以总而言之，你可以使用reversed(range(10))而不会对性能造成任何影响。

我认为许多人(包括我自己)可能对以相反的顺序遍历现有列表的常见情况更感兴趣，而不是像标题中所述的那样，而不仅仅是为这种遍历生成索引。

尽管如此，在这种情况下，所有正确答案仍然完全正确，我想指出的是，在狼的回答中进行的性能比较仅用于生成索引。因此，我为以相反的顺序遍历现有列表创建了类似的基准测试。

a[::-1]是最快的。

注:如果你想要更详细的不同反转替代方案及其性能分析，请查看这个答案很好。

先决条件:

a = list(range(10))

杰森的回答:

%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)

马提瑙的回答:

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

米夏拉Šrajer的回答:

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

野猪的回答:

%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)

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

注:我在JupyterLab测试，它有方便的“魔术命令”。%timeit。它在底层使用标准timeit.timeit。已为Python 3.7.3测试

因为range(n)产生了一个可迭代对象，所以你可以做各种各样的事情来产生你想要的结果，比如:

range(n)[::-1]

如果循环没问题，我们可以创建一个队列:

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

或者可以使用reverse()方法:

reverse(range(n))