Percorrer uma lista na ordem inversa em Python
Pergunta
Para que eu possa começar a partir de len(collection)
e fim em collection[0]
.
EDIT: Desculpe, eu esqueci de mencionar que eu também quero ser capaz de acessar o índice de loop
.Solução
Use o built-in reversed()
função :
>>> a = ["foo", "bar", "baz"]
>>> for i in reversed(a):
... print(i)
...
baz
bar
foo
Para também acessar o índice original, use enumerate()
em sua lista antes de passar -lo para reversed()
:
>>> for i, e in reversed(list(enumerate(a))):
... print(i, e)
...
2 baz
1 bar
0 foo
Desde enumerate()
retorna um gerador e geradores não pode ser revertida, você precisa convertê-lo para um list
primeiro.
Outras dicas
Você pode fazer:
for item in my_list[::-1]:
print item
(ou o que você quer fazer no loop for.)
A fatia [::-1]
inverte a lista no loop for (mas realmente não vai modificar a sua lista de "permanente").
Se você precisar o índice de loop, e não quero percorrer toda a lista duas vezes, ou usar a memória extra, eu ia escrever um gerador.
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
Isso pode ser feito da seguinte forma:
for i in range(len(collection)-1, -1, -1): print collection[i] # print(collection[i]) for python 3. +
Portanto, o seu palpite estava muito perto :) Um pouco estranho, mas é basicamente dizendo: começar com 1 a menos de len(collection)
, continue indo até chegar a apenas antes -1, em passos de -1.
FYI, a função help
é muito útil, pois permite que você veja os documentos de algo a partir do console Python, por exemplo:
help(range)
O reversed
builtin função é útil:
for item in reversed(sequence):
O documentação para revertida explica suas limitações.
Para os casos em que têm de andar numa sequência em sentido inverso ao longo com o índice (por exemplo, para as modificações no local mudando o comprimento da sequência), que têm esta função definido um módulo minha codeutil:
import itertools
def reversed_enumerate(sequence):
return itertools.izip(
reversed(xrange(len(sequence))),
reversed(sequence),
)
Este evita a criação de uma cópia da sequência. Obviamente, as limitações reversed
ainda se aplicam.
>>> l = ["a","b","c","d"]
>>> l.reverse()
>>> l
['d', 'c', 'b', 'a']
ou
>>> print l[::-1]
['d', 'c', 'b', 'a']
Que tal sem recriar uma nova lista, você pode fazer por indexação:
>>> foo = ['1a','2b','3c','4d']
>>> for i in range(len(foo)):
... print foo[-(i+1)]
...
4d
3c
2b
1a
>>>
ou
>>> length = len(foo)
>>> for i in range(length):
... print foo[length-i-1]
...
4d
3c
2b
1a
>>>
Eu gosto da abordagem gerador de one-liner:
((i, sequence[i]) for i in reversed(xrange(len(sequence))))
Além disso, você poderia usar um "intervalo" ou "contar" funções. Da seguinte forma:
a = ["foo", "bar", "baz"]
for i in range(len(a)-1, -1, -1):
print(i, a[i])
3 baz
2 bar
1 foo
Você também pode usar "contar" a partir itertools como a seguir:
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
Use list.reverse()
e depois iterate como faria normalmente.
def reverse(spam):
k = []
for i in spam:
k.insert(0,i)
return "".join(k)
para o que sempre vale a pena você pode fazê-lo assim também. muito simples.
a = [1, 2, 3, 4, 5, 6, 7]
for x in xrange(len(a)):
x += 1
print a[-x]
Se você precisa o índice e sua lista é pequena, a forma mais legível é fazer reversed(list(enumerate(your_list)))
como a resposta aceita diz. Mas isso cria uma cópia da sua lista, por isso, se sua lista está a ocupar uma grande parte da sua memória você vai ter que subtrair o índice retornado por enumerate(reversed())
de len()-1
.
Se você só precisa fazer isso uma vez:
a = ['b', 'd', 'c', 'a']
for index, value in enumerate(reversed(a)):
index = len(a)-1 - index
do_something(index, value)
ou se você precisa fazer isso várias vezes que você deve usar um gerador:
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)
a função inversa vem a calhar aqui:
myArray = [1,2,3,4]
myArray.reverse()
for x in myArray:
print x
As outras respostas são bons, mas se você quer fazer como Lista estilo compreensão
collection = ['a','b','c']
[item for item in reversed( collection ) ]
uso integrado em função reversed()
por objecto sequência, este método tem o efeito de todas as sequências
Você também pode usar um loop while
:
i = len(collection)-1
while i>=0:
value = collection[i]
index = i
i-=1
Você pode usar um índice negativo em um ordinário para loop:
>>> collection = ["ham", "spam", "eggs", "baked beans"]
>>> for i in range(1, len(collection) + 1):
... print(collection[-i])
...
baked beans
eggs
spam
ham
Para acessar o índice como se estivesse repetindo a frente sobre uma cópia invertida da i - 1
coleção, use:
>>> for i in range(1, len(collection) + 1):
... print(i-1, collection[-i])
...
0 baked beans
1 eggs
2 spam
3 ham
Para acessar o original, un-invertida índice, o uso 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
Uma maneira expressiva para alcançar reverse(enumerate(collection))
em python 3:
zip(reversed(range(len(collection))), reversed(collection))
em python 2:
izip(reversed(xrange(len(collection))), reversed(collection))
Eu não sei por que não temos um atalho para isso, por exemplo:.
def reversed_enumerate(collection):
return zip(reversed(range(len(collection))), reversed(collection))
ou porque não temos reversed_range()
Uma abordagem sem importações:
for i in range(1,len(arr)+1):
print(arr[-i])
ou
for i in arr[::-1]:
print(i)
Para usar índices negativos:. Iniciar a -1 e a etapa volta por -1 em cada iteração
>>> a = ["foo", "bar", "baz"]
>>> for i in range(-1, -1*(len(a)+1), -1):
... print i, a[i]
...
-1 baz
-2 bar
-3 foo
Uma maneira simples:
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])
eu acho que esta é também uma maneira simples de fazê-lo ... leia a partir do final e manter diminuindo até que o comprimento da lista, uma vez que nunca executar o índice de "fim", portanto, acrescentou -1 também
Assumindo tarefa é encontrar último elemento que satisfaz uma condição em uma lista (ou seja, em primeiro lugar quando se olha para trás), estou ficando seguintes números:
>>> 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
Assim, o mais feio xrange(len(xs)-1,-1,-1)
opção é o mais rápido.
Se você não se importa o índice de ser negativo, você pode fazer:
>>> a = ["foo", "bar", "baz"]
>>> for i in range(len(a)):
... print(~i, a[~i]))
-1 baz
-2 bar
-3 foo
Eu acho que a maneira mais elegante é transformar enumerate
e reversed
usando o seguinte gerador
(-(ri+1), val) for ri, val in enumerate(reversed(foo))
que gera um reverso da enumerate
iteração
Exemplo:
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)))
]
Resultado:
[6, 4, 2]