在Python中以相反的顺序遍历列表

所以我可以从

len（collection）

开始，然后在

collection[0]

结束

我还希望能够访问循环索引。

使用内置功能：

>>> a = ["foo", "bar", "baz"]
>>> for i in reversed(a):
...     print(i)
... 
baz
bar
foo

要同时访问原始索引，请在将其传递到

reversed（）

之前在列表中使用：

由于

enumerate（）

返回一个生成器，并且生成器不能反转，因此需要首先将其转换为

列表。
使用
list.reverse（）
，然后像通常一样迭代

在这里，倒车功能很方便：

myArray = [1,2,3,4]
myArray.reverse()
for x in myArray:
    print x

你可以做：

for item in my_list[::-1]:
    print item

>>> a = ["foo", "bar", "baz"]
>>> for i in range(len(a)):
...     print(~i, a[~i]))
-1 baz
-2 bar
-3 foo

（或者在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控制台查看文档，例如：

帮助（范围）
内置的
反向功能非常方便：

for item in reversed(sequence):

相反的方法解释了它的局限性

对于必须沿着索引反向遍历序列的情况（例如，对于更改序列长度的就地修改），我将此函数定义为my codeutil模块：

from six.moves import zip as izip, range as xrange

def reversed_enumerate(sequence):
    return izip(
        reversed(xrange(len(sequence))),
        reversed(sequence),
    )

这样可以避免创建序列的副本。显然，
相反的
限制仍然适用。
其他答案很好，但如果你想这样做的话
列出理解风格

collection = ['a','b','c']
[item for item in reversed( collection ) ]

在不重新创建新列表的情况下，您可以通过索引执行以下操作：

>>> foo = ['1a','2b','3c','4d']
>>> for i in range(len(foo)):
...     print foo[-(i+1)]
...
4d
3c
2b
1a
>>>

或

我喜欢单直线发电机方法：

（（i，序列[i]）表示反向（xrange（len（序列）））

或

使用负指数：从-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

您还可以使用
while
循环：

i = len(collection)-1
while i>=0:
    value = collection[i]
    index = i
    i-=1

没有进口的方法：

for i in range(1,len(arr)+1):
    print(arr[-i])

或

无论如何，你也可以这样做。很简单

a = [1, 2, 3, 4, 5, 6, 7]
for x in xrange(len(a)):
    x += 1
    print a[-x]

您可以在普通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

一个简单的方法：

n = int(input())
arr = list(map(int, input().split()))

for i in reversed(range(0, n)):
    print("%d %d" %(i, arr[i]))

此外，您可以使用“范围”或“计数”函数。
详情如下:

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

在Python3中，list创建了一个副本，因此
反转（list（enumerate（collection））
可能效率低下，但生成另一个列表时没有进行优化

如果集合确实是一个列表，那么最好将复杂性隐藏在迭代器后面

def reversed_enumerate(collection: list):
    for i in range(len(collection)-1, -1, -1):
        yield i, collection[i]

因此，最干净的是：

for i, elem in reversed_enumerate(['foo', 'bar', 'baz']):
    print(i, elem)

我认为这也是一种简单的方法…从末尾开始读取并不断递减直到列表的长度，因为我们从不执行因此添加的“end”索引-1也
如果您需要索引并且列表很小，最可读的方法是执行
反转（列表（枚举（您的列表）））
正如公认的答案所说。但这会创建列表的副本，因此如果列表占用了大量内存，则必须从
len（）-1
中减去
enumerate（reversed（））
返回的索引

如果您只需要做一次：

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)

li = [1,2,3,4,5,6]
len_li = len(li)
gen = (len_li-1-i for i in range(len_li))

假设任务是在列表中找到满足某些条件的最后一个元素（即向后看时的第一个元素），我得到以下数字：

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

>>min（timeit.repeat（'for i in xrange（len（xs）-1，-1，-1）：\n如果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如果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如果128==x:break'，setup='xs，n=range（256），0'，repeat=8））
4.931743860244751
>>>min（timeit.repeat（'for i，x in enumerate（xs[：：-1]）：\n如果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如果128==xs[i-1]：break'，setup='xs，n=range（256），0'，repeat=8））
6.286104917526245
>>>min（timeit.repeat（'i=len（xs）\n而0

因此，最丑的选项
xrange（len（xs）-1，-1，-1）
是最快的。
如果你不介意索引为负，你可以：

for item in my_list[::-1]:
    print item

>>> a = ["foo", "bar", "baz"]
>>> for i in range(len(a)):
...     print(~i, a[~i]))
-1 baz
-2 bar
-3 foo

我认为最优雅的方法是使用以下生成器转换
枚举
和
反向

(-(ri+1), val) for ri, val in enumerate(reversed(foo))

它生成一个与
枚举
迭代器相反的

例如：

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]

您可以使用生成器：

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)

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

希望这对您有所帮助。
list.reverse（）没有返回值没有创建副本，元素在遍历时会动态反转！这是所有这些迭代函数（都以“ed”结尾）的一个重要特性。@Greg Hewgill no，它是原始函数的迭代器，没有创建副本！为了避免混淆：
reversed（）
不修改列表。
reversed（）
不复制列表（否则需要额外的内存）。如果需要修改列表，请使用
alist.reverse（）
；如果需要以相反顺序复制列表，请使用
alist[：-1]
。不过，在这个答案中，请使用list（枚举（a））创建副本。@JF，reversed（）不创建副本，但list（enumerate（））创建副本。
[：：-1][6, 4, 2]

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