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

Question

所以我可以从头开始len(collection)并结束collection[0].

编辑:对不起,我忘了提到我也希望能够访问循环索引.

Answer 1

使用内置reversed()功能:

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

要访问原始索引:

>>> for i, e in reversed(list(enumerate(a))):
...     print(i, e)
... 
2 baz
1 bar
0 foo

Answer 2

你可以做:

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

(或者你想在for循环中做什么.)

该[::-1]切片反转for循环在列表中(但不会实际修改列表的"永久").

Answer 3

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

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

Answer 4

它可以这样做:

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

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

所以你的猜测非常接近:)有点尴尬,但它基本上是这样说:从1开始不到len(collection),继续前进直到-1到-1之前,步长为-1.

Fyi,该help函数非常有用,因为它允许您从Python控制台查看某些文档,例如:

help(range)

Answer 5

该reversed内置功能非常方便:

for item in reversed(sequence):

该文档的逆转说明了它的局限性.

对于我必须与索引一起反向遍历序列的情况(例如,对于更改序列长度的就地修改),我将此函数定义为我的codeutil模块:

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

这个避免了创建序列的副本.显然,这些reversed限制仍然适用.

Answer 6

没有导入的方法：

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

或者

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

Answer 7

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

要么

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

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

Answer 9

不管它的价值如何，你也可以这样做。很简单。

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

Answer 10

如果不重新创建新列表,可以通过索引来完成:

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

Answer 11

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

Answer 12

我喜欢单线发电机的方法:

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

Answer 13

另外，您可以使用“范围”或“计数”功能。如下：

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

Answer 14

list.reverse()照常使用，然后进行迭代。

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

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

Answer 16

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

Python 2：

>>> 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)是最快的。

Python 3（不同机器）：

>>> timeit.timeit('for i in range(len(xs)-1,-1,-1):\n    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))):\n    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):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
1.9069805409999958
>>> timeit.timeit('for i, x in enumerate(xs[::-1]):\n    if 128 == x: break', setup='xs, n = range(256), 0', number=400000)
2.960720073999994
>>> timeit.timeit('for i in range(len(xs), 0, -1):\n    if 128 == xs[i - 1]: break', setup='xs, n = range(256), 0', number=400000)
5.316207007999992
>>> timeit.timeit('i = len(xs)\nwhile 0 < i:\n    i -= 1\n    if 128 == xs[i]: break', setup='xs, n = range(256), 0', number=400000)
5.802550058999998

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