在 Python 中以相反的顺序遍历列表[重复]

问题描述：

如何在 Python 中以相反顺序遍历列表？所以我可以从 开始collection[len(collection)-1]并以 结束collection[0]。

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

解决方案 1：

使用内置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第一个。

解决方案 2：

您可以执行以下操作：

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

（或者您想在 for 循环中执行的任何操作。）

切片[::-1]会在 for 循环中反转列表（但实际上不会“永久”修改列表）。

解决方案 3：

可以这样做：

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

    # print(collection[i]) for python 3. +

所以你的猜测非常接近:) 有点尴尬，但它基本上是说：从小于 1 开始len(collection)，继续，直到你到达 -1 之前，以 -1 为步长。

仅供参考，该help函数非常有用，因为它允许您从 Python 控制台查看某些内容的文档，例如：

help(range)

解决方案 4：

如果您需要循环索引，并且不想遍历整个列表两次，或者使用额外的内存，我会编写一个生成器。

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

解决方案 5：

不导入的方法：

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

时间复杂度O(n)，空间复杂度O(1)。

一种在内存中创建新列表的方法，对于大型列表要小心：

for i in arr[::-1]:
    print(i)

时间复杂度O(n)，空间复杂度O(n)。

解决方案 6：

内置函数reversed很方便：

for item in reversed(sequence):

reversed 的文档解释了它的局限性。

对于我必须沿着索引反向遍历序列的情况（例如，对于改变序列长度的就地修改），我在我的 codeutil 模块中定义了这个函数：

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

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

这样就避免了创建序列的副本。显然，reversed限制仍然存在。

解决方案 7：

另外，您可以使用“range”或“count”函数。如下所示：

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

解决方案 8：

在 python 3 中，列表会创建一个副本，因此reversed(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)

解决方案 9：

如果不重新创建新列表，您可以通过索引来实现：

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

或者

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

解决方案 10：

>>> l = ["a","b","c","d"]
>>> l.reverse()
>>> l
['d', 'c', 'b', 'a']

或者

>>> print l[::-1]
['d', 'c', 'b', 'a']

解决方案 11：

我喜欢单行生成器方法：

((i, sequence[i]) for i in reversed(xrange(len(sequence))))

解决方案 12：

list.reverse()像平常一样使用然后进行迭代。

http://docs.python.org/tutorial/datastructs.html

解决方案 13：

不管怎样，你也可以这样做。非常简单。

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

解决方案 14：

def reverse(spam):
    k = []
    for i in spam:
        k.insert(0,i)
    return "".join(k)

解决方案 15：

如果您需要索引并且列表很小，最易读的方法是reversed(list(enumerate(your_list)))按照接受的答案进行操作。但这会创建列表的副本，因此如果您的列表占用了很大一部分内存，则必须减去enumerate(reversed())from返回的索引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)

解决方案 16：

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

Python 2：

>>> min(timeit.repeat('for i in xrange(len(xs)-1,-1,-1):
    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))):
    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):
    if 128 == x: break', setup='xs, n = range(256), 0', repeat=8))
4.931743860244751
>>> min(timeit.repeat('for i, x in enumerate(xs[::-1]):
    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):
    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', repeat=8))
6.286104917526245
>>> min(timeit.repeat('i = len(xs)
while 0 < i:
    i -= 1
    if 128 == xs[i]: break', setup='xs, n = range(256), 0', repeat=8))
8.384078979492188

因此，最丑陋的选择xrange(len(xs)-1,-1,-1)却是最快的。

Python 3（不同机器）：

>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):
    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.48873088900001
>>> timeit.timeit('for i in reversed(range(0, len(xs))):
    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
4.540959084000008
>>> timeit.timeit('for i, x in enumerate(reversed(xs), 1):
    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):
    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):
    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)
while 0 < i:
    i -= 1
    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998

这里，enumerate(reversed(xs), 1)是最快的。

解决方案 17：

如果您不介意索引为负数，您可以执行以下操作：

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

解决方案 18：

我认为最优雅的方法是转换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]

解决方案 19：

反向函数在这里就派上用场了：

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

解决方案 20：

要使用负索引：从 -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

解决方案 21：

您还可以使用while循环：

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

解决方案 22：

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

解决方案 23：

作为 Python 初学者，我发现这种方式更容易理解和反转列表。

说 numlst = [1, 2, 3, 4]

对于范围内的 i（len（numlst）-1，-1，-1）：

ie., for i in range(3,-1,-1), where 3 is length of list minus 1,
second -1 means list starts from last element and 
third -1 signifies it will traverse in reverse order.

打印（numlst[ i ]）

对数 = 4, 3, 2, 1

解决方案 24：

其他答案都很好，但如果你想按照列表理解风格去做

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

解决方案 25：

input_list = ['foo','bar','baz']
for i in range(-1,-len(input_list)-1,-1)
    print(input_list[i])

我认为这也是一种简单的方法...从末尾读取并不断减少直到列表的长度，因为我们从不执行“结束”索引，因此也添加了 -1

解决方案 26：

我很困惑为什么到目前为止没有出现明显的选择：

如果reversed()由于您有一个发电机（如的情况enumerate()）而无法工作，则只需使用sorted()：

>>> l = list( 'abcdef' )
>>> sorted( enumerate(l), reverse=True )
[(5, 'f'), (4, 'e'), (3, 'd'), (2, 'c'), (1, 'b'), (0, 'a')]

解决方案 27：

一个简单的方法：

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

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

解决方案 28：

您可以使用发电机：

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

希望这对你有帮助。