所以我可以从len(collection)开始，到collection[0]结束。
答案 0 :(得分：981)
使用内置的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。
答案 1 :(得分：145)
你可以这样做：
for item in my_list[::-1]:
print item
（或者你想在for循环中做什么。）
[::-1]切片会反转for循环中的列表（但实际上不会“永久”修改您的列表）。
答案 2 :(得分：63)
如果你需要循环索引，并且不想遍历整个列表两次，或者使用额外的内存，我会写一个生成器。
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
答案 3 :(得分：52)
可以这样做：
for i in range(len(collection)-1, -1, -1):
print collection[i]
# print(collection[i]) for python 3. +
所以你的猜测非常接近:)有点尴尬但它基本上是这样说：从小于len(collection)的1开始，继续前进直到-1到-1之前，步长为-1。
Fyi，help函数非常有用，因为它允许您从Python控制台查看某些文档，例如：
help(range)
答案 4 :(得分：20)
reversed内置函数非常方便：
for item in reversed(sequence):
反向的documentation解释了它的局限性。
对于我必须与索引一起反向遍历序列的情况（例如，对于改变序列长度的就地修改），我将此函数定义为我的codeutil模块：
import itertools
def reversed_enumerate(sequence):
return itertools.izip(
reversed(xrange(len(sequence))),
reversed(sequence),
)
这个避免创建序列的副本。显然，reversed限制仍然适用。
答案 5 :(得分：7)
>>> l = ["a","b","c","d"]
>>> l.reverse()
>>> l
['d', 'c', 'b', 'a']
OR
>>> print l[::-1]
['d', 'c', 'b', 'a']
答案 6 :(得分：5)
如果不重新创建新列表，可以通过编制索引来实现：
>>> 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
>>>
答案 7 :(得分：5)
我喜欢单线发电机方法：
((i, sequence[i]) for i in reversed(xrange(len(sequence))))
答案 8 :(得分：4)
使用list.reverse()，然后像往常一样进行迭代。
答案 9 :(得分：4)
此外，您可以使用“范围”或“计数”功能。 如下：
a = ["foo", "bar", "baz"]
for i in range(len(a)-1, -1, -1):
print(i, a[i])
3 baz
2 bar
1 foo
您还可以使用itertools中的“count”，如下所示：
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
答案 10 :(得分：2)
def reverse(spam):
k = []
for i in spam:
k.insert(0,i)
return "".join(k)
答案 11 :(得分：2)
对于它有价值的你也可以这样做。非常简单。
a = [1, 2, 3, 4, 5, 6, 7]
for x in xrange(len(a)):
x += 1
print a[-x]
答案 12 :(得分：1)
对序列对象使用内置函数reversed()，此方法具有所有序列的效果
答案 13 :(得分：1)
其他答案都很好，但如果你想做的话 列表理解风格
collection = ['a','b','c']
[item for item in reversed( collection ) ]
答案 14 :(得分：1)
您还可以使用while循环：
i = len(collection)-1
while i>=0:
value = collection[i]
index = i
i-=1
答案 15 :(得分：1)
一个简单的方法是：
for i in range(1,len(arr)+1):
print(arr[-i])
答案 16 :(得分：1)
a = ["foo", "bar", "baz"]
print a[::~0]
解决此问题的另一种方法，此代码针对循环运行递减
答案 17 :(得分：1)
在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()
答案 18 :(得分：1)
如果您需要索引并且列表很小，那么最容易理解的方法是按照接受的答案所述进行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)
或者如果您需要多次执行此操作，则应使用生成器：
{{1}}
答案 19 :(得分：0)
我认为最优雅的方法是使用以下生成器来转换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]
答案 20 :(得分：0)
使用负指数：从-1开始，每次迭代后退-1。
public string getAppPoolName(int pid)
{
ServerManager serverManager = new ServerManager();
ApplicationPoolCollection apc = serverManager.ApplicationPools;
foreach (var app in apc)
{
var workers = app.WorkerProcesses;
foreach (var w in workers)
{
if (w.ProcessId == pid)
{
return app.Name;
}
}
}
return string.Empty;
}
答案 21 :(得分：0)
如果您不介意索引为负，则可以执行以下操作：
>>> a = ["foo", "bar", "baz"]
>>> for i in range(len(a)):
... print(~i, a[~i]))
-1 baz
-2 bar
-3 foo
答案 22 :(得分：0)
假设任务是在列表中找到满足某些条件的最后一个元素（即，向后看时是第一个），我得到以下数字：
>>> 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)是最快的。
答案 23 :(得分：0)
echo $JAVA_HOME我认为这也是一种简单的方法...从结尾读取并不断递减直到列表的长度，因为我们从不执行“ end”索引，因此也添加了-1。
答案 24 :(得分：0)
一种简单的方法：
n = int(input())
arr = list(map(int, input().split()))
for i in reversed(range(0, n)):
print("%d %d" %(i, arr[i]))
答案 25 :(得分：0)
反向功能在这里派上用场了：
myArray = [1,2,3,4]
myArray.reverse()
for x in myArray:
print x
答案 26 :(得分：-1)
您可以使用生成器：
li = [1,2,3,4,5,6]
len_li = len(li)
gen = (len_li-1-i for i in range(len_li))
最后：
for i in gen:
print(li[i])
希望这对您有所帮助。