python堆栈反向输出列表_python - 在Python中以相反顺序遍历列表 - 堆栈内存溢出

===============>>#1 票数：1075 已采纳

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

===============>>#2 票数：155

你可以做：

for item in my_list[::-1]:

print item

(或者您想要在for循环中执行的任何操作。)

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

===============>>#3 票数：64

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

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

===============>>#4 票数：58

可以这样完成：

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)

===============>>#5 票数：21

reversed内置函数很方便：

for item in reversed(sequence):

反向文档说明了其局限性。

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

import itertools

def reversed_enumerate(sequence):

return itertools.izip(

reversed(xrange(len(sequence))),

reversed(sequence),

)

这避免了创建序列的副本。 显然， reversed限制仍然适用。

===============>>#6 票数：9

>>> l = ["a","b","c","d"]

>>> l.reverse()

>>> l

['d', 'c', 'b', 'a']

要么

>>> print l[::-1]

['d', 'c', 'b', 'a']

===============>>#7 票数：6

无需重新创建新列表，可以通过建立索引来实现：

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

>>>

===============>>#8 票数：6

我喜欢单线生成器方法：

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

===============>>#9 票数：6

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

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

===============>>#10 票数：5

===============>>#11 票数：3

def reverse(spam):

k = []

for i in spam:

k.insert(0,i)

return "".join(k)

===============>>#12 票数：3

对于有什么价值的事情，您也可以这样做。 很简单。

a = [1, 2, 3, 4, 5, 6, 7]

for x in xrange(len(a)):

x += 1

print a[-x]

===============>>#13 票数：2

没有导入的方法：

for i in range(1,len(arr)+1):

print(arr[-i])

要么

for i in arr[::-1]:

print(i)

===============>>#14 票数：2

如果您需要索引并且列表较小，则最reversed(list(enumerate(your_list)))方法是按照已接受的答案进行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)

===============>>#15 票数：1

对序列对象使用内置函数reversed() ，此方法具有所有序列的效果

===============>>#16 票数：1

您还可以使用while循环：

i = len(collection)-1

while i>=0:

value = collection[i]

index = i

i-=1

===============>>#17 票数：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

===============>>#18 票数：1

一种在python 3中实现reverse(enumerate(collection))的表达方式：

zip(reversed(range(len(collection))), reversed(collection))

在python 2：

izip(reversed(xrange(len(collection))), reversed(collection))

我不确定为什么我们没有快捷方式，例如：

def reversed_enumerate(collection):

return zip(reversed(range(len(collection))), reversed(collection))

还是为什么我们没有reversed_range()

===============>>#19 票数：1

反向功能在这里很方便：

myArray = [1,2,3,4]

myArray.reverse()

for x in myArray:

print x

===============>>#20 票数：0

其他答案都不错，但是如果您要作为列表理解样式

collection = ['a','b','c']

[item for item in reversed( collection ) ]

===============>>#21 票数：0

要使用负索引，请执行以下操作：从-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

===============>>#22 票数：0

一个简单的方法：

n = int(input())

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

for i in reversed(range(0, n)):

print("%d %d" %(i, arr[i]))

===============>>#23 票数：0

input_list = ['foo','bar','baz']

for i in range(-1,-len(input_list)-1,-1)

print(input_list[i])

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

===============>>#24 票数：0

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

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

===============>>#25 票数：0

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

>>> a = ["foo", "bar", "baz"]

>>> for i in range(len(a)):

... print(~i, a[~i]))

-1 baz

-2 bar

-3 foo

===============>>#26 票数：0

我认为最优雅的方法是使用以下生成器来转换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]

===============>>#27 票数：-1

您可以使用生成器：

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

希望对您有帮助。

ask by Joan Venge translate from so