Traverse une liste dans l'ordre inverse en Python

Pour que je puisse commencer à partir de len(collection) et de fin dans collection[0].

EDIT: Désolé, j'ai oublié de mentionner que je veux aussi être en mesure d'accéder à l'indice de boucle.

InformationsquelleAutor Joan Venge | 2009-02-09
  1. 1007

    Utiliser le haut- inversé() fonction:

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

    Également accéder à l'index d'origine, utilisez enumerate() sur votre liste avant de passer à reversed():

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

    Depuis enumerate() retourne un générateur et les générateurs ne peut pas être inversée, vous devez le convertir en un list premier.

    • Merci. Par curiosité, est ce que cette méthode inversée, crée une copie distincte de la collection ou tout simplement modifie la boucle?
    • Aucune copie n'est créé, les éléments sont inversés à la volée pendant la traversée! C'est une caractéristique importante de l'ensemble de ces fonctions itératives (qui se terminent tous sur “ed”).
    • L'inversion de fonction() fait une copie de la collection. Pour modifier une liste existante, utilisez la .méthode reverse ().
    • Hewgill Non, c'est un itérateur sur l'original, pas de copie est créée!
    • vous avez raison bien sûr, mais j'ai été en utilisant les mêmes mots que la question posée par Joan, de sorte que la réponse serait plus facile à comprendre. Sur le plan conceptuel, il crée une copie. Dans la mise en œuvre, il utilise un itérateur.
    • Votre nouveau morceau de code pour accéder à l'index d'origine crée une deuxième copie de l'original de la collection. Il serait mieux de tout simplement faire quelque chose comme i = len(a) - 1 - ridx
    • Suce plutôt que c'est de parcourir l'ensemble de la liste avant d'itération... Encore upvoted.
    • Pour éviter la confusion: reversed() ne pas modifier la liste. reversed() n'est pas de faire une copie de la liste (sinon elle aurait besoin de O(N) de la mémoire supplémentaire). Si vous avez besoin de modifier la liste, utilisez alist.reverse(); si vous avez besoin d'une copie de la liste dans l'ordre inverse utiliser alist[::-1].
    • dans cette réponse, bien que, la liste(énumérer(a)) permet de créer une copie.
    • Il n'est pas assez de faire une copie, il semble faire la même logique que manuellement la marche à l'envers. Si vous appelez inversée, puis modifier la liste, puis itérer sur la liste inversée, les modifications seront prises en compte par inversée().
    • Il rend absolument une copie de la liste. Plus précisément un zip de la liste avec la position d'index.
    • n' pas créer une copie de [a, b, c].
    • Je pense qu'il y a une certaine confusion ici au sujet de exactement ce qui exemple, nous sommes en train de discuter. Le premier exemple utilise uniquement inversé(); le deuxième exemple utilise inversé(liste(enumerate())). Clairement le deuxième exemple fait plus de copies que le premier. Je pense que vous êtes tout à fait correct à un certain niveau. 🙂
    • JF, inversé() ne fait pas une copie, mais la liste(enumerate()) permet de faire une copie.
    • Merci pour les commentaires les gars, mais on dirait qu'il ya confusion sur la façon dont ces méthodes sont mises en œuvre. Par la copie que je voulais dire, une copie en profondeur, pas un itérateur. Les itérateurs sont beaux mais au plus profond de copies permettrait de ralentir mon code considérable, pour plusieurs millions de données.
    • vous ne devriez pas être concerné par la "profond" versus "shallow" copies. Qui n'a d'importance que vous avez à traiter avec des listes imbriquées. Même un "shallow" copie sera cher - il permet de dupliquer l'ensemble de la liste. Je crois que ma réponse est le seul qui correspond à vos spécifications ET n'utilise pas de mémoire supplémentaire.
    • Grâce Triptyque, c'est ce que je veux dire, pas de collecte de copie, mais un itérateur copie.
    • Bien que reversed(list(enumerate(a))) fonctionne, il n'est pas optimisé. Une alternative est proposée ici à l'aide d'une fonction lambda: christophe-simonis-à-petit.blogspot.ca/2008/08/...
    • Je pense que enumerate(reversed(a)) serait aussi une solution. Cependant, des indices seront dans l'ordre inverse c'est à dire le dernier élément a un index de 0
    • les indices peuvent être produit en inversé facilement à l'aide de len(a)-i-1, et si l'accès à une liste b de la même longueur, b[-i-1] est équivalent à b[len(a)-i-1]
    • En fait, vous pouvez utiliser ce générateur de (-(ri+1), val) for ri, val in enumerate(reversed(foo)), voir ma réponse par exemple
    • Je préfères @disooqi / Francsics version (for i in range(len(a)-1, -1, -1)) puisque c'est une ligne et vraiment à éviter toute liste de copie ou de création d'une liste.
    • Pourquoi ne pas nous utiliser un tuple?

    InformationsquelleAutor Greg Hewgill
  2. 147

    Que vous pouvez faire:

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

    (Ou ce que vous voulez faire dans la boucle for.)

    La [::-1] tranche inverse de la liste dans la boucle for (mais ne pas vraiment modifier votre liste de "permanence").

    • [::-1] crée une copie superficielle, donc il ne change pas le tableau ni "de façon permanente", ni de "temporaire".
    • C'est un peu plus lent que d'utiliser inversé, au moins sous Python 2.7 (testé).
    • Cela fonctionne pour les objets de requête, inversé() ne fonctionne pas. Merci!!!
    • Comment cette réponse œuvres: il crée un des tranches de copie de la liste avec les paramètres: point de départ: non spécifié (qui devient la longueur de la liste commence alors à la fin), point de fin: non spécifié (qui devient un peu de magie nombre d'autres que 0, probablement -1, ainsi se termine au début) et pas: -1 (itère vers l'arrière dans la liste, 1 élément à la fois).
    • J'ai testé aussi (python 2.7) et il était d'environ 10% plus lent à utiliser [::-1] vs reversed()
    InformationsquelleAutor mipadi
  3. 63

    Si vous avez besoin de l'indice de boucle, et ne veulent pas de parcourir l'ensemble de la liste deux fois, ou de l'utilisation de la mémoire supplémentaire, je ferais un générateur. 

    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
    • Je voudrais appeler la fonction enumerate_reversed, mais que peut-être seulement mon goût. Je crois que votre réponse est la plus propre pour la question spécifique.
    • reversed(xrange(len(L))) produit les mêmes indices que xrange(len(L)-1, -1, -1).
    • ouais à l'époque, je pensais que j'avais quelque raison de ne pas le faire de cette façon, mais maintenant je ne me souviens pas. Modifier maintenant.
    • C', mais comme un one-liner générateur: ((i, la séquence[i]) for i in inversé(xrange(len(séquence))))
    • Je préfère moins de pièces en mouvement pour comprendre: for index, item in enumerate(reversed(L)): print len(L)-1-index, item
    • J'ai juste eu à composer avec le fait qu'énumérer à partir inversé() ne sont pas de rendement inversée index et votre code a beaucoup aidé. Cette méthode devrait être dans la bibliothèque standard.
    • inversé() n'est pas nécessaire dans ce cas. xrange(len(L)-1, -1, -1) devrait faire le travail. En passant, comment se fait - reversed(xrange()) fonctionne mais reversed(enumerate()) ne l'est pas?
    • inversé(xrange()) fonctionne car un xrange objet a l' __inversé__ méthode ainsi que l' __len__ et __ _ _ getitem__ méthodes, et inversé peut détecter et de les utiliser. Mais un énumérer objet n'a pas __inversé__, __len__ ou __getitem__. Mais pourquoi n'énumère pas les avoir? Je ne sais pas qui.
    • parce que enumerate est un pur objet itérateur où, comme xrange est techniquement un sequece. iter(xrange(..)) subit les mêmes restrictions que enumerate et tout autre itérateur ont.

    InformationsquelleAutor Triptych
  4. 53

    Il peut être fait comme ceci:

    for i in range(len(collection)-1, -1, -1): 
imprimer collection[i] 

# print(collection[i]) pour python 3. +

    Si votre proposition était assez proche 🙂 Un peu maladroit mais c'est essentiellement à dire: commencer par 1 moins de len(collection), continuez jusqu'à ce que vous obtenez tout simplement avant de -1, par pas de -1.

    Pour info, le help fonction est très utile car il vous permet de voir les docs pour quelque chose à partir de la console Python, par exemple:

    help(range)

    • Pour les versions de Python antérieures à la version 3.0, je crois xrange est préférable de gamme pour les grands len(collection).
    • Je crois que vous avez raison 🙂 iirc, range() génère l'ensemble de la gamme, comme un tableau, mais xrange() retourne un itérateur qui génère uniquement les valeurs telles qu'elles sont nécessaires.
    • Cela semble juste trop bizarre avec autant de -1s'. Je voudrais juste dire reversed(xrange(len(collection)))
    InformationsquelleAutor Alan Rowarth
  5. 20

    La reversed builtin fonction est très pratique:

    for item in reversed(sequence):

    La la documentation renversé explique ses limites.

    Pour le cas où je dois marcher une séquence en sens inverse le long de l'index (par exemple, pour les modifications de la modification de la longueur de la séquence), j'ai cette fonction définie à l'une de mes codeutil module:

    import itertools
def reversed_enumerate(sequence):
    return itertools.izip(
        reversed(xrange(len(sequence))),
        reversed(sequence),
    )

    Cela, on évite la création d'une copie de la séquence. De toute évidence, la reversed limitations s'appliquent toujours.

    InformationsquelleAutor tzot
  6. 7
    >>> l = ["a","b","c","d"]
>>> l.reverse()
>>> l
['d', 'c', 'b', 'a']

    OU

    >>> print l[::-1]
['d', 'c', 'b', 'a']
    InformationsquelleAutor Freddy
  7. 5

    Comment sur sans recréer une nouvelle liste, vous pouvez le faire par l'indexation:

    >>> 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
>>>
    InformationsquelleAutor James Sapam
  8. 5

    J'aime les one-liner générateur approche:

    ((i, sequence[i]) for i in reversed(xrange(len(sequence))))
    InformationsquelleAutor lkraider
  9. 5

    Aussi, vous pouvez utiliser soit "plage" ou "compter" des fonctions.
    Comme suit:

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

3 baz
2 bar
1 foo

    Vous pouvez également utiliser le "compteur" de itertools comme suit:

    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
    • Le code dans votre premier bloc, il ne produit pas le droit de sortie; la sortie est en fait 3 foo\n2 bar\n1 baz
    • Pour éviter d'utiliser "a[i-1]" dans le premier exemple, l'utilisation de cette gamme "range(len(a)-1, -1, -1)". C'est plus simple.
    InformationsquelleAutor disooqi
  10. 4

    Utilisation list.reverse() et puis itérer comme vous le feriez normalement.

    http://docs.python.org/tutorial/datastructures.html

    InformationsquelleAutor Bill Konrad
  11. 2
    def reverse(spam):
    k = []
    for i in spam:
        k.insert(0,i)
    return "".join(k)
    InformationsquelleAutor Jase
  12. 2

    pour ce que jamais, il vaut la peine de vous peut faire comme ça aussi. très simple.

    a = [1, 2, 3, 4, 5, 6, 7]
for x in xrange(len(a)):
    x += 1
    print a[-x]
    • Vous pouvez également faire print a[-(x+1)] et d'éviter la ré-affectation des index dans le corps de la boucle.
    InformationsquelleAutor emorphus
  13. 1

    l'inverse de la fonction est très pratique ici:

    myArray = [1,2,3,4]
myArray.reverse()
for x in myArray:
    print x
    • liste.reverse() n'a pas de valeur de retour
    InformationsquelleAutor bchhun
  14. 1

    Autres réponses sont bonnes, mais si vous voulez faire comme
    Compréhension de liste style

    collection = ['a','b','c']
[item for item in reversed( collection ) ]
    • N'est-ce pas la même chose que inversé(collection)? L'ajout de la compréhension de liste ne fait rien, à l'exception de calculs inutiles. C'est comme d'écrire a = [article pour l'article dans [1, 2, 3]] vs a = [1, 2, 3].
    InformationsquelleAutor fedmich
  15. 1

    utilisation de la fonction intégrée dans reversed() pour objet de séquence,cette méthode a pour effet de toutes les séquences

    plus détaillée lien de référence

    InformationsquelleAutor lazybios
  16. 1

    Vous pouvez également utiliser un while boucle:

    i = len(collection)-1
while i>=0:
    value = collection[i]
    index = i
    i-=1
    InformationsquelleAutor Yuval A.
  17. 1

    Une approche facile est:

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

    Vous pouvez utiliser un indice négatif ordinaire dans une boucle for:

    >>> collection = ["ham", "spam", "eggs", "baked beans"]
>>> for i in range(1, len(collection) + 1):
...     print(collection[-i])
... 
baked beans
eggs
spam
ham

    Pour accéder à l'index comme si vous étiez une itération sur une inversion de la copie de la collecte, de l'utilisation i - 1:

    >>> for i in range(1, len(collection) + 1):
...     print(i-1, collection[-i])
... 
0 baked beans
1 eggs
2 spam
3 ham

    Pour accéder à l'original, de l'onu-inversé index, utilisez 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
    InformationsquelleAutor Malcolm
  19. 1

    Une manière expressive pour atteindre reverse(enumerate(collection)) en python 3:

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

    en python 2:

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

    Je ne suis pas sûr de savoir pourquoi nous n'avons pas une abréviation, pour cela, par exemple.:

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

    ou pourquoi nous n'avons pas reversed_range()

    InformationsquelleAutor Barnabas Szabolcs
  20. 1
    a = ["foo", "bar", "baz"]
print a[::~0]

    une autre façon de résoudre ce problème, l'exécution de ce code décrémenté pour boucle

    • Alors que ce bout de code peut résoudre le problème, ça n'explique pas pourquoi et comment il répond à la question. Veuillez inclure une explication de votre code, comme qui aide vraiment à améliorer la qualité de votre post. Rappelez-vous que vous répondez à la question pour les lecteurs dans l'avenir, et ces personnes pourraient ne pas connaître les raisons de votre code suggestion.
    • Merci @LucaKiebel, prendra soin la prochaine fois
    InformationsquelleAutor paras chauhan
  21. 1

    Si vous avez besoin de l'index et votre liste est petite, la plus lisible est de faire reversed(list(enumerate(your_list))) comme la accepté de répondre à dit. Mais cela crée une copie de votre liste, de sorte que si votre liste est de prendre une grande partie de votre mémoire, vous devrez soustraire l'index retourné par enumerate(reversed()) de len()-1.

    Si vous avez juste besoin de le faire qu'une fois:

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

for index, value in enumerate(reversed(a)):
    index = len(a)-1 - index

    do_something(index, value)

    ou si vous avez besoin de le faire plusieurs fois, vous devez utiliser un générateur:

    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)
    InformationsquelleAutor Boris
  22. 0

    À utiliser des indices: commencer à -1 et du recul de -1 à chaque itération.

    >>> a = ["foo", "bar", "baz"]
>>> for i in range(-1, -1*(len(a)+1), -1):
...     print i, a[i]
... 
-1 baz
-2 bar
-3 foo
    InformationsquelleAutor stroz
  23. 0

    Une manière simple : 

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

for i in reversed(range(0, n)):
    print("%d %d" %(i, arr[i]))
    InformationsquelleAutor rashedcs
  24. 0
    input_list = ['foo','bar','baz']
for i in range(-1,-len(input_list)-1,-1)
    print(input_list[i])

    je pense que c'est aussi la manière la plus simple... lire la de fin et garder écoulera jusqu'à la longueur de la liste, puisque nous n'avons jamais exécuter la "fin" de l'index donc ajouté -1 aussi

    InformationsquelleAutor Varun Maurya
  25. 0

    En supposant que la tâche est de trouver le dernier élément qui satisfait une certaine condition dans une liste (c'est à dire en premier sur la recherche à l'envers), je reçois des numéros suivants:

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

    Donc, le plus laid option xrange(len(xs)-1,-1,-1) est le plus rapide.

    InformationsquelleAutor wonder.mice
  26. 0

    Si vous n'avez pas l'esprit de l'indice est négative, vous pouvez le faire:

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

    Je pense que la façon la plus élégante est de transformer enumerate et reversed à l'aide de la suite de générateur

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

    qui génère un revers de la enumerate itérateur

    Exemple:

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

    Résultat:

    [6, 4, 2]
    InformationsquelleAutor CervEd