遍历Python中相反的顺序列表
https://stackoverflow.com/questions/529424
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
Russian题
因此，我可以从len(collection)启动并在collection[0]结束。
编辑：对不起，我忘了提我也希望能够访问环路索引
。解决方案
使用内置的 reversed() 功能：
>>> a = ["foo", "bar", "baz"]
>>> for i in reversed(a):
... print(i)
...
baz
bar
foo
要还可以访问原来的索引，使用 enumerate() 您的名单才通过它reversed()：
>>> for i, e in reversed(list(enumerate(a))):
... print(i, e)
...
2 baz
1 bar
0 foo
由于enumerate()返回一个发电机和发电机无法逆转的，你需要把它转换到一个list。
其他提示
您可以这样做：
for item in my_list[::-1]:
print item
（或任何你想在for循环做的。）
在[::-1]片反转for循环在列表中（但不会实际修改列表的“永久”）。
如果您需要循环索引，并且不希望遍历整个列表两次，或使用额外的内存，我会写一台发电机。
def reverse_enum(L):
for index in reversed(xrange(len(L))):
yield index, L[index]
L = ['foo', 'bar', 'bas']
for index, item in reverse_enum(L):
print index, item
它可以这样来完成：
for i in range(len(collection)-1, -1, -1):
print collection[i]
# print(collection[i]) for python 3. +
所以，你的猜测是八九不离十:)有点别扭，但它基本上是说：开始比len(collection)少1，继续下去，直到你到达之前-1，由-1步骤。
据透露，该help功能，因为它允许您查看的文档可以从Python控制台的东西非常有用的，例如：
help(range)
在reversed内建功能是很方便的：
for item in reversed(sequence):
有颠倒的文档解释了其局限性。
有关在那里我走在反向的序列与索引一起（例如，用于就地修改改变序列长度）的情况下，我已这个函数定义的我的codeutil模块：
import itertools
def reversed_enumerate(sequence):
return itertools.izip(
reversed(xrange(len(sequence))),
reversed(sequence),
)
这一个避免创建的序列的拷贝。显然，reversed限制仍然适用。
>>> l = ["a","b","c","d"]
>>> l.reverse()
>>> l
['d', 'c', 'b', 'a']
OR
>>> print l[::-1]
['d', 'c', 'b', 'a']
如何不会重新创建一个新的列表，你可以通过索引做的：
>>> foo = ['1a','2b','3c','4d']
>>> for i in range(len(foo)):
... print foo[-(i+1)]
...
4d
3c
2b
1a
>>>
OR
>>> length = len(foo)
>>> for i in range(length):
... print foo[length-i-1]
...
4d
3c
2b
1a
>>>
我喜欢的单行发生器的方法：
((i, sequence[i]) for i in reversed(xrange(len(sequence))))
此外，可以使用任一“范围”或“计数”的功能。 如下：
a = ["foo", "bar", "baz"]
for i in range(len(a)-1, -1, -1):
print(i, a[i])
3 baz
2 bar
1 foo
您也可以使用 “计数” 从itertools如下：
a = ["foo", "bar", "baz"]
from itertools import count, takewhile
def larger_than_0(x):
return x > 0
for x in takewhile(larger_than_0, count(3, -1)):
print(x, a[x-1])
3 baz
2 bar
1 foo
使用list.reverse()然后迭代像平时那样。
def reverse(spam):
k = []
for i in spam:
k.insert(0,i)
return "".join(k)
对于什么都它的价值，你可以像这样做了。很简单。
a = [1, 2, 3, 4, 5, 6, 7]
for x in xrange(len(a)):
x += 1
print a[-x]
如果您需要的索引和列表很小，最可读的方式就像是公认的答案说做reversed(list(enumerate(your_list)))。但是，这将创建列表的副本，因此，如果您的列表占用了内存的很大一部分，你必须减去enumerate(reversed())由len()-1返回的索引。
如果您只是需要做一次：
a = ['b', 'd', 'c', 'a']
for index, value in enumerate(reversed(a)):
index = len(a)-1 - index
do_something(index, value)
或者如果你需要这个多次做你应该使用一个发电机：
def enumerate_reversed(lyst):
for index, value in enumerate(reversed(lyst)):
index = len(lyst)-1 - index
yield index, value
for index, value in enumerate_reversed(a):
do_something(index, value)
反向功能派上用场这里：
myArray = [1,2,3,4]
myArray.reverse()
for x in myArray:
print x
在其他的答案是好的，但如果你想要做的 的列表解析式
collection = ['a','b','c']
[item for item in reversed( collection ) ]
使用内置的序列对象函数reversed()，这种方法具有的所有序列的效果
您也可以使用while循环：
i = len(collection)-1
while i>=0:
value = collection[i]
index = i
i-=1
可以在一个普通的使用负折射率for循环：
>>> collection = ["ham", "spam", "eggs", "baked beans"]
>>> for i in range(1, len(collection) + 1):
... print(collection[-i])
...
baked beans
eggs
spam
ham
要访问，就像你经集合的反转副本向前遍历索引，使用i - 1：
>>> for i in range(1, len(collection) + 1):
... print(i-1, collection[-i])
...
0 baked beans
1 eggs
2 spam
3 ham
要访问原始的，未反转索引，使用len(collection) - i：
>>> for i in range(1, len(collection) + 1):
... print(len(collection)-i, collection[-i])
...
3 baked beans
2 eggs
1 spam
0 ham
这是表达方式在Python 3实现reverse(enumerate(collection))：
zip(reversed(range(len(collection))), reversed(collection))
在Python 2：
izip(reversed(xrange(len(collection))), reversed(collection))
我不知道为什么我们没有这个的简写，例如：
def reversed_enumerate(collection):
return zip(reversed(range(len(collection))), reversed(collection))
为什么我们没有reversed_range()
没有进口的一种方法：
for i in range(1,len(arr)+1):
print(arr[-i])
或
for i in arr[::-1]:
print(i)
要使用负指数：在-1启动和在每次迭代由-1退一步
>>> a = ["foo", "bar", "baz"]
>>> for i in range(-1, -1*(len(a)+1), -1):
... print i, a[i]
...
-1 baz
-2 bar
-3 foo
一个简单的方法：
n = int(input())
arr = list(map(int, input().split()))
for i in reversed(range(0, n)):
print("%d %d" %(i, arr[i]))
input_list = ['foo','bar','baz']
for i in range(-1,-len(input_list)-1,-1)
print(input_list[i])
我觉得这个也很简单的方法来做到这一点...从最终读取和保持递减，直到列表的长度，因为我们从来没有执行“结束”指数因此加-1还
假设任务是找到（向后看时即第一）满足一些条件列表中的最后一个元素，我发现了以下数字：
>>> min(timeit.repeat('for i in xrange(len(xs)-1,-1,-1):\n if 128 == xs[i]: break', setup='xs, n = range(256), 0', repeat=8))
4.6937971115112305
>>> min(timeit.repeat('for i in reversed(xrange(0, len(xs))):\n if 128 == xs[i]: break', setup='xs, n = range(256), 0', repeat=8))
4.809093952178955
>>> min(timeit.repeat('for i, x in enumerate(reversed(xs), 1):\n if 128 == x: break', setup='xs, n = range(256), 0', repeat=8))
4.931743860244751
>>> min(timeit.repeat('for i, x in enumerate(xs[::-1]):\n if 128 == x: break', setup='xs, n = range(256), 0', repeat=8))
5.548468112945557
>>> min(timeit.repeat('for i in xrange(len(xs), 0, -1):\n if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', repeat=8))
6.286104917526245
>>> min(timeit.repeat('i = len(xs)\nwhile 0 < i:\n i -= 1\n if 128 == xs[i]: break', setup='xs, n = range(256), 0', repeat=8))
8.384078979492188
因此，最丑陋的选项xrange(len(xs)-1,-1,-1)是最快的。
如果你不介意的指数为负数，你可以这样做：
>>> a = ["foo", "bar", "baz"]
>>> for i in range(len(a)):
... print(~i, a[~i]))
-1 baz
-2 bar
-3 foo
我认为最优雅的方式是使用以下发生器变换enumerate和reversed
(-(ri+1), val) for ri, val in enumerate(reversed(foo))
，其生成所述enumerate迭代器的反向
示例：
foo = [1,2,3]
bar = [3,6,9]
[
bar[i] - val
for i, val in ((-(ri+1), val) for ri, val in enumerate(reversed(foo)))
]
结果：
[6, 4, 2]
