[英]How to traverse a list in reverse order in Python (index-style: '… in range(…)' only)
[英]Traverse a list in reverse order in Python [duplicate]
所以我可以从collection[len(collection)-1]
开始并以collection[0]
结束。
我还希望能够访问循环索引。
使用内置的reversed()
函数:
>>> a = ["foo", "bar", "baz"]
>>> for i in reversed(a):
... print(i)
...
baz
bar
foo
要访问原始索引,请在将列表传递给reversed()
之前在列表中使用enumerate()
reversed()
:
>>> for i, e in reversed(list(enumerate(a))):
... print(i, e)
...
2 baz
1 bar
0 foo
由于enumerate()
返回一个生成器并且生成器无法反转,因此您需要先将其转换为list
。
你可以做:
for item in my_list[::-1]:
print item
(或者任何你想在 for 循环中做的事情。)
[::-1]
切片在 for 循环中反转列表(但实际上不会“永久”修改您的列表)。
可以这样做:
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)
如果您需要循环索引,并且不想遍历整个列表两次,或者使用额外的内存,我会编写一个生成器。
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
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
限制仍然适用。
没有导入的方法:
for i in range(1,len(arr)+1):
print(arr[-i])
或者
for i in arr[::-1]:
print(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 中的“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
如果不重新创建新列表,您可以通过索引来完成:
>>> 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
>>>
>>> l = ["a","b","c","d"]
>>> l.reverse()
>>> l
['d', 'c', 'b', 'a']
或者
>>> print l[::-1]
['d', 'c', 'b', 'a']
在 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)
我喜欢单线性生成器方法:
((i, sequence[i]) for i in reversed(xrange(len(sequence))))
使用list.reverse()
然后像往常一样迭代。
对于任何值得的,你也可以这样做。 很简单。
a = [1, 2, 3, 4, 5, 6, 7]
for x in xrange(len(a)):
x += 1
print a[-x]
def reverse(spam):
k = []
for i in spam:
k.insert(0,i)
return "".join(k)
如果您需要索引并且您的列表很小,那么最易读的方法是像接受的答案所说的那样做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)
反向功能在这里派上用场:
myArray = [1,2,3,4]
myArray.reverse()
for x in myArray:
print x
我认为最优雅的方法是使用以下生成器转换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]
对序列对象使用内置函数reversed()
,此方法具有所有序列的效果
要使用负索引:从 -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 循环中使用负索引:
>>> 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
假设任务是找到满足列表中某个条件的最后一个元素(即向后看时首先),我得到以下数字:
>>> 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)
是最快的。
如果你不介意指数为负,你可以这样做:
>>> a = ["foo", "bar", "baz"]
>>> for i in range(len(a)):
... print(~i, a[~i]))
-1 baz
-2 bar
-3 foo
作为 python 的初学者,我发现这种方式更容易理解并反转列表。
说 numlst = [1, 2, 3, 4]
对于我在范围内(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[我])
o/p = 4、3、2、1
其他答案很好,但如果你想做列表理解风格
collection = ['a','b','c']
[item for item in reversed( collection ) ]
一个简单的方法:
n = int(input())
arr = list(map(int, input().split()))
for i in reversed(range(0, n)):
print("%d %d" %(i, arr[i]))
input_list = ['foo','bar','baz']
for i in range(-1,-len(input_list)-1,-1)
print(input_list[i])
我认为这也是一种简单的方法...从末尾读取并不断递减直到列表的长度,因为我们从未执行过“结束”索引,因此也添加了 -1
我很困惑为什么到目前为止没有出现明显的选择:
如果reversed()
不工作,因为你有一个生成器(如enumerate()
的情况),只需使用sorted()
:
>>> l = list( 'abcdef' )
>>> sorted( enumerate(l), reverse=True )
[(5, 'f'), (4, 'e'), (3, 'd'), (2, 'c'), (1, 'b'), (0, 'a')]
您可以使用生成器:
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])
希望这对你有帮助。
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.