在Python中以相反的顺序遍历列表
Posted
技术标签:
【中文标题】在Python中以相反的顺序遍历列表【英文标题】：Traverse a list in reverse order in Python 【发布时间】：2010-10-06 11:27:50 【问题描述】：所以我可以从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。
【讨论】：
没有创建副本，元素在遍历过程中被反转！这是所有这些迭代函数的一个重要特征（它们都以“ed”结尾）。 @Greg Hewgill 不，它是对原始版本的迭代器，不会创建副本！ 为避免混淆：reversed() 不会修改列表。 reversed() 不会复制列表（否则将需要 O(N) 额外内存）。如果您需要修改列表，请使用alist.reverse()；如果您需要以相反顺序的列表副本，请使用alist[::-1]。
在这个答案中，list(enumerate(a)) 确实创建了一个副本。
@JF, reversed() 不会复制，但 list(enumerate()) 会复制。【参考方案2】：
使用list.reverse()，然后像往常一样迭代。
http://docs.python.org/tutorial/datastructures.html
【讨论】：
对于大型列表，这是对 CPU 时间的浪费。请改用reversed。【参考方案3】：
reverse 函数在这里派上用场：
myArray = [1,2,3,4]
myArray.reverse()
for x in myArray:
print x
【讨论】：
list.reverse() 没有返回值【参考方案4】：你可以这样做：
for item in my_list[::-1]:
print item
（或者你想在 for 循环中做的任何事情。）
[::-1] 切片在 for 循环中反转列表（但实际上不会“永久”修改您的列表）。
【讨论】：
[::-1] 创建一个浅拷贝，因此它不会“永久”或“临时”更改数组。
这比使用 reversed 稍微慢一些，至少在 Python 2.7 下（已测试）。
这个答案的工作原理：它使用参数创建列表的切片副本：start point：未指定（成为列表的长度，因此开始最后），结束点：未指定（变成0以外的某个幻数，可能是-1，所以在开始时结束）和步骤：-1（向后迭代列表，一次1 项）。
我也对此进行了测试（python 2.7），使用 [::-1] 与 reversed() 相比要慢约 10%【参考方案5】：
如果您需要循环索引，并且不想遍历整个列表两次，或者使用额外的内存，我会编写一个生成器。
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
【讨论】：
我会调用函数 enumerate_reversed，但这可能只是我的口味。我相信您的回答对于特定问题来说是最干净的。reversed(xrange(len(L))) 产生与xrange(len(L)-1, -1, -1) 相同的索引。
我更喜欢更少的活动部件来理解：for index, item in enumerate(reversed(L)): print len(L)-1-index, item
@Triptych 我只需要处理从 reversed() 枚举不会产生反向索引的事实，并且您的代码有很大帮助。这个方法应该在标准库中。
reversed(xrange()) 之所以有效，是因为 xrange 对象具有 __reversed__ 方法以及 __len__ 和 __getitem__ 方法，并且 reversed 可以检测到并使用它们。但是枚举对象没有 __reversed__、__len__ 或 __getitem__。但是为什么没有列举它们呢？我不知道。【参考方案6】：
可以这样做：
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)
【讨论】：
对于 Python 3.0 之前的版本，我认为 xrange 比 range 更适合大 len(collection)。 我相信你是对的 :) iirc，range() 将整个范围生成为一个数组，但 xrange() 返回一个迭代器，它只在需要时生成值。 这么多-1 看起来太奇怪了。我只想说reversed(xrange(len(collection)))
感谢您对参数值的解释，我也喜欢基于相同向后范围迭代器的 Barney Szabolcs 解决方案。您的解释很容易理解。【参考方案7】：
reversed 内置函数很方便：
for item in reversed(sequence):
用于 reversed 的 documentation 解释了它的局限性。
对于我必须与索引一起反向遍历序列的情况（例如，对于更改序列长度的就地修改），我将这个函数定义为我的 codeutil 模块：
from six.moves import zip as izip, range as xrange
def reversed_enumerate(sequence):
return izip(
reversed(xrange(len(sequence))),
reversed(sequence),
)
这个避免了创建序列的副本。显然，reversed 的限制仍然适用。
【讨论】：
【参考方案8】：其他答案都很好，但如果你想这样做 列表理解风格
collection = ['a','b','c']
[item for item in reversed( collection ) ]
【讨论】：
这不就是和reverse(collection)一样吗？除了不必要的计算之外，添加列表推导什么都不做。这就像写 a = [item for item in [1, 2, 3]] vs a = [1, 2, 3]。【参考方案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】：def reverse(spam):
k = []
for i in spam:
k.insert(0,i)
return "".join(k)
【讨论】：
【参考方案11】：我喜欢单线生成器方法：
((i, sequence[i]) for i in reversed(xrange(len(sequence))))
【讨论】：
【参考方案12】：>>> l = ["a","b","c","d"]
>>> l.reverse()
>>> l
['d', 'c', 'b', 'a']
或
>>> print l[::-1]
['d', 'c', 'b', 'a']
【讨论】：
【参考方案13】：要使用负索引：从 -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
【讨论】：
【参考方案14】：您也可以使用while 循环：
i = len(collection)-1
while i>=0:
value = collection[i]
index = i
i-=1
【讨论】：
【参考方案15】：没有导入的方法：
for i in range(1,len(arr)+1):
print(arr[-i])
或者，这种方法会在内存中创建一个新列表，所以要小心大列表
for i in arr[::-1]:
print(i)
【讨论】：
这个答案应该是最重要的，第一种方法使列表保持不变，没有复制，我们只是向后移动索引。非常快。第二种方法将创建一个新列表，因此请注意。【参考方案16】：对于任何值得的事情，您也可以这样做。很简单。
a = [1, 2, 3, 4, 5, 6, 7]
for x in xrange(len(a)):
x += 1
print a[-x]
【讨论】：
你也可以print a[-(x+1)]，避免在循环体中重新分配索引。【参考方案17】：
您可以在普通的 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
【讨论】：
【参考方案18】：一个简单的方法：
n = int(input())
arr = list(map(int, input().split()))
for i in reversed(range(0, n)):
print("%d %d" %(i, arr[i]))
【讨论】：
【参考方案19】：此外，您可以使用“范围”或“计数”函数。 如下：
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
【讨论】：
第一个块中的代码没有产生正确的输出；输出实际上是3 foo\n2 bar\n1 baz
为避免在第一个示例中使用“a[i-1]”，请使用此范围“range(len(a)-1, -1, -1)”。这更加简化了。【参考方案20】：
在 python 3 中，list 创建了一个副本，因此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)
【讨论】：
这让我哭了 @CervEd 你说的很对，回来的时候我也哭了。?? 更新了我的答案。 ——虽然射程让我还是有点哭……【参考方案21】：input_list = ['foo','bar','baz']
for i in range(-1,-len(input_list)-1,-1)
print(input_list[i])
我认为这也是一种简单的方法...从末尾读取并一直递减直到列表的长度，因为我们从不执行“结束”索引，因此也添加了 -1
【讨论】：
【参考方案22】：如果您需要索引并且您的列表很小，最易读的方法是像接受的答案所说的那样做reversed(list(enumerate(your_list)))。但这会创建列表的副本，因此如果您的列表占用了大部分内存，则必须从 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)
【讨论】：
【参考方案23】：假设任务是在列表中找到满足某些条件的最后一个元素（即向后看时首先），我得到以下数字：
>>> 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？因为 range 在 3.6 中仍然可以完成 xrange 的工作【参考方案24】：如果您不介意索引为负数，您可以这样做：
>>> a = ["foo", "bar", "baz"]
>>> for i in range(len(a)):
... print(~i, a[~i]))
-1 baz
-2 bar
-3 foo
【讨论】：
【参考方案25】：我认为最优雅的方法是使用以下生成器转换 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]
【讨论】：
【参考方案26】：您可以使用生成器：
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])
希望对你有所帮助。
【讨论】：
【参考方案27】：我很困惑为什么到目前为止还没有出现明显的选择：
如果reversed() 因您有生成器而无法工作（如enumerate() 的情况），请使用sorted()：
>>> l = list( 'abcdef' )
>>> sorted( enumerate(l), reverse=True )
[(5, 'f'), (4, 'e'), (3, 'd'), (2, 'c'), (1, 'b'), (0, 'a')]
【讨论】：
以上是关于在Python中以相反的顺序遍历列表的主要内容，如果未能解决你的问题，请参考以下文章