Atravessar uma lista em ordem inversa em Python


701

Para que eu possa começar len(collection)e terminar collection[0].

Eu também quero poder acessar o índice do loop.

Respostas:


1181

Use a reversed()função interna:

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

Para acessar também o índice original, use enumerate()na sua lista antes de passá-lo para reversed():

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

Como enumerate()retorna um gerador e os geradores não podem ser revertidos, é necessário convertê-lo para um listprimeiro.


130
Nenhuma cópia é criada, os elementos são revertidos em tempo real durante a navegação! Esse é um recurso importante de todas essas funções de iteração (que terminam em "ed").
9289 Konrad Rudolph

9
@ Greg Hewgill Não, é um iterador sobre o original, nenhuma cópia é criada!
André

92
Para evitar a confusão: reversed()não modifica a lista. reversed()não faz uma cópia da lista (caso contrário, exigiria memória adicional O (N)). Se você precisar modificar a lista, use alist.reverse(); se você precisar de uma cópia da lista em ordem inversa, use alist[::-1].
jfs

90
nesta resposta, porém, list (enumerate (a)) cria uma cópia.
Triptych

42
@ JF, reverse () não faz uma cópia, mas list (enumerate ()) FAZ uma cópia.
Triptych

172

Você pode fazer:

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

(Ou o que você quiser fazer no loop for.)

A [::-1]fatia reverte a lista no loop for (mas na verdade não modifica sua lista "permanentemente").


24
[::-1]cria uma cópia superficial, portanto, não altera a matriz nem "permanentemente" nem "temporariamente".
jfs

6
Isso é um pouco mais lento do que usar o reverso, pelo menos no Python 2.7 (testado).
kgriffs

14
Como esta resposta funciona : ele cria uma cópia fatiada da lista com os parâmetros: ponto inicial : não especificado (torna-se o tamanho da lista e começa no final), ponto final : não especificado (torna-se um número mágico que 0, provavelmente -1, termina no início ) e passo : -1(itera para trás na lista, 1item de cada vez).
Edward

1
I testado neste, bem como (python 2,7) e foi ~ 10% mais lenta para utilização [:: - 1] vsreversed()
RustyShackleford

67

Se você precisar do índice de loop e não quiser percorrer a lista inteira duas vezes ou usar memória extra, eu escreveria 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

3
Eu chamaria a função enumerate_reversed, mas isso pode ser apenas o meu gosto. Acredito que sua resposta é a mais limpa para uma pergunta específica.
tzot

1
reversed(xrange(len(L)))produz os mesmos índices que xrange(len(L)-1, -1, -1).
jfs

2
Eu prefiro menos partes móveis para entender:for index, item in enumerate(reversed(L)): print len(L)-1-index, item
Don Kirkby

2
@ Triptych Eu apenas tive que lidar com o fato de que enumerar de reversed () não produzirá índices revertidos, e seu código ajudou muito. Este método deve estar na biblioteca padrão.
oski86

2
reversed (xrange ()) funciona porque um objeto xrange possui o método __reversed__, bem como os métodos __len__ e __getitem__, e o reversed pode detectar isso e usá-los. Mas um objeto enumerado não possui __reversed__, __len__ ou __getitem__. Mas por que não enumerá-los? Eu não sei disso.
FutureNerd 24/09/15

60

Isso pode ser feito assim:

para i no intervalo (len (coleção) -1, -1, -1):
    coleção impressa [i]

    # print (coleção [i]) para python 3.

Então, seu palpite foi bem próximo :) Um pouco estranho, mas é basicamente o seguinte: comece com 1 a menos que len(collection), continue até chegar antes de -1, em etapas de -1.

Fyi, a helpfunção é muito útil, pois permite exibir os documentos de algo no console do Python, por exemplo:

help(range)


1
Para versões do Python anteriores à 3.0, acredito que o xrange é preferível a faixa para len grande (coleção).
9789 Brian M. Hunt

Acredito que você esteja correto :) iirc, range () gera todo o intervalo como uma matriz, mas xrange () retorna um iterador que gera apenas os valores conforme necessário.
9249 Alan Rowarth

11
Isso parece muito estranho com tantos -1. Eu diria apenasreversed(xrange(len(collection)))
musiphil

22

A reversedfunção embutida é útil:

for item in reversed(sequence):

A documentação para reverso explica suas limitações.

Nos casos em que eu tenho que percorrer uma sequência ao contrário, juntamente com o índice (por exemplo, para modificações no local que alteram o comprimento da sequência), eu tenho essa função definida no meu módulo 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, oreversed limitações ainda se aplicam.


9

Que tal, sem recriar uma nova lista, você pode fazer isso indexando:

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

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

OU

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

7

Eu gosto da abordagem de gerador de uma linha:

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

7

Além disso, você pode usar as funções "range" ou "count". Do seguinte modo:

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 "count" do itertools da seguinte maneira:

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

O código no seu primeiro bloco não produz a saída correta; a saída é na verdade3 foo\n2 bar\n1 baz
amiller27

Para evitar o uso de "a [i-1]" no primeiro exemplo, use esse intervalo "range (len (a) -1, -1, -1)". Isso é mais simplificado.
Francisc


4

Uma abordagem sem importações:

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

ou

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

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

3

pelo que vale a pena, você também pode fazê-lo assim. muito simples.

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

1
Você também pode fazer print a[-(x+1)]e evitar reatribuir o índice no corpo do loop.
Malcolm

2

Uma maneira expressiva de obter reverse(enumerate(collection))em python 3:

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

no python 2:

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

Não sei por que não temos uma abreviação para isso, por exemplo:

def reversed_enumerate(collection):
    return zip(reversed(range(len(collection))), reversed(collection))

ou por que não temos reversed_range()


2

Se você precisa do índice e sua lista é pequena, a maneira mais legível é fazer o reversed(list(enumerate(your_list)))que a resposta aceita diz. Mas isso cria uma cópia da sua lista, portanto, se a sua lista estiver ocupando uma grande parte da sua memória, você deverá subtrair o índice retornado 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ê precisar fazer isso várias vezes, use 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)

1

a função reversa é útil aqui:

myArray = [1,2,3,4]
myArray.reverse()
for x in myArray:
    print x

list.reverse () não tem valor de retorno
Georg Schölly

1

Você também pode usar um whileloop:

i = len(collection)-1
while i>=0:
    value = collection[i]
    index = i
    i-=1

1

Você pode usar um índice negativo em um loop for comum:

>>> 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 você estivesse iterando adiante em uma cópia invertida da coleção, use i - 1:

>>> 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 índice original não revertido, use 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

1

Se você não se importa que o índice seja negativo, você pode:

>>> a = ["foo", "bar", "baz"]
>>> for i in range(len(a)):
...     print(~i, a[~i]))
-1 baz
-2 bar
-3 foo

1

Eu acho que a maneira mais elegante é transformar enumeratee reversedusar o seguinte gerador

(-(ri+1), val) for ri, val in enumerate(reversed(foo))

que gera o inverso do enumerateiterador

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]

0

As outras respostas são boas, mas se você quiser fazer o estilo de compreensão da lista

collection = ['a','b','c']
[item for item in reversed( collection ) ]

1
Não é o mesmo que reverso (coleção)? Adicionar a compreensão da lista não faz nada, exceto computação desnecessária. É como escrever a = [item por item em [1, 2, 3]] vs a = [1, 2, 3].
precisa saber é o seguinte

0

Para usar índices negativos: inicie em -1 e volte em -1 a 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

0

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

0
input_list = ['foo','bar','baz']
for i in range(-1,-len(input_list)-1,-1)
    print(input_list[i])

Eu acho que esse também é um jeito simples de fazer isso ... leia do final e continue diminuindo até o tamanho da lista, já que nunca executamos o índice "end", portanto adicionamos -1 também


0

Assumindo que a tarefa é encontrar o último elemento que satisfaça alguma condição de uma lista (ou seja, primeiro ao olhar para trás), estou recebendo os 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

Portanto, a opção mais feia xrange(len(xs)-1,-1,-1)é a mais rápida.


-1

você pode usar um gerador:

li = [1,2,3,4,5,6]
len_li = len(li)
gen = (len_li-1-i for i in range(len_li))

finalmente:

for i in gen:
    print(li[i])

espero que isso ajude você.

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.