Durchlaufen Sie eine Liste in Python in umgekehrter Reihenfolge

So kann ich beginnen len(collection)und enden in collection[0].

Ich möchte auch auf den Schleifenindex zugreifen können.

Verwenden Sie die integrierte reversed()Funktion:

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

Um auch auf den ursprünglichen Index zuzugreifen, verwenden Sie ihn enumerate()in Ihrer Liste, bevor Sie ihn an reversed()folgende Adresse übergeben :

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

Da enumerate()ein Generator zurückgegeben wird und Generatoren nicht rückgängig gemacht werden können, müssen Sie ihn in einen listersten konvertieren .

Du kannst tun:

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

(Oder was auch immer Sie in der for-Schleife tun möchten.)

Das [::-1]Slice kehrt die Liste in der for-Schleife um (ändert Ihre Liste jedoch nicht "dauerhaft").

Wenn Sie den Schleifenindex benötigen und nicht die gesamte Liste zweimal durchlaufen oder zusätzlichen Speicher verwenden möchten, würde ich einen Generator schreiben.

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

Es kann so gemacht werden:

für i im Bereich (len (Sammlung) -1, -1, -1):
    Drucksammlung [i]

    # print (Sammlung [i]) für Python 3. +

Ihre Vermutung war also ziemlich nah :) Ein wenig umständlich, aber es heißt im Grunde: Beginnen Sie mit 1 weniger als len(collection), fahren Sie fort, bis Sie kurz vor -1 in Schritten von -1 ankommen.

Zu Ihrer Information, die helpFunktion ist sehr nützlich, da Sie damit die Dokumente für etwas von der Python-Konsole aus anzeigen können, z.

help(range)

Die reversedeingebaute Funktion ist praktisch:

for item in reversed(sequence):

Die Dokumentation für umgekehrt erklärt die Einschränkungen.

Für die Fälle, in denen ich eine Sequenz zusammen mit dem Index in umgekehrter Reihenfolge durchlaufen muss (z. B. für direkte Änderungen, die die Sequenzlänge ändern), habe ich diese Funktion für mein Codeutil-Modul definiert:

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

Dieser vermeidet das Erstellen einer Kopie der Sequenz. Offensichtlich reversedgelten die Einschränkungen weiterhin.

Wie wäre es, wenn Sie keine neue Liste erstellen, indem Sie Folgendes indizieren:

>>> foo = ['1a','2b','3c','4d']
>>> for i in range(len(foo)):
...     print foo[-(i+1)]
...
4d
3c
2b
1a
>>>

ODER

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

ODER

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

Ich mag den Einzeiler-Generator-Ansatz:

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

Sie können auch die Funktionen "Bereich" oder "Zählen" verwenden. Wie folgt:

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

3 baz
2 bar
1 foo

Sie können "count" auch aus itertools wie folgt verwenden:

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

Verwenden Sie list.reverse()und iterieren Sie dann wie gewohnt.

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

Ein Ansatz ohne Importe:

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

oder

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

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

für was auch immer es wert ist, du kannst es auch so machen. sehr einfach.

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

Ein ausdrucksstarker Weg, um reverse(enumerate(collection))in Python 3 zu erreichen :

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

in Python 2:

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

Ich bin mir nicht sicher, warum wir dafür keine Abkürzung haben, z.

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

oder warum wir nicht haben reversed_range()

Wenn Sie den Index benötigen und Ihre Liste klein ist, ist es am besten zu lesen, reversed(list(enumerate(your_list)))wie in der akzeptierten Antwort angegeben. Aber dies erstellt eine Kopie der Liste, so dass , wenn Ihre Liste wird einen großen Teil Ihres Speichers Aufnahme finden Sie den Index zurück abziehen müssen enumerate(reversed())aus len()-1.

Wenn Sie es nur einmal tun müssen:

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

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

    do_something(index, value)

oder wenn Sie dies mehrmals tun müssen, sollten Sie einen Generator verwenden:

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)

Die Umkehrfunktion ist hier praktisch:

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

Sie können auch eine whileSchleife verwenden:

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

Sie können einen negativen Index in einer normalen for-Schleife verwenden:

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

Verwenden Sie Folgendes, um auf den Index zuzugreifen, als würden Sie eine umgekehrte Kopie der Sammlung vorwärts iterieren i - 1:

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

Verwenden Sie Folgendes, um auf den ursprünglichen, nicht umgekehrten Index zuzugreifen 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

Wenn es Ihnen nichts ausmacht, dass der Index negativ ist, können Sie Folgendes tun:

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

Ich denke, der eleganteste Weg ist, den folgenden Generator zu transformieren enumerateund zu reversedverwenden

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

Dies erzeugt eine Umkehrung des enumerateIterators

Beispiel:

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

Ergebnis:

[6, 4, 2]

Die anderen Antworten sind gut, aber wenn Sie als Listenverständnisstil tun möchten

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

So verwenden Sie negative Indizes: Beginnen Sie bei -1 und treten Sie bei jeder Iteration um -1 zurück.

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

Ein einfacher Weg:

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

Ich denke, dies ist auch eine einfache Möglichkeit, dies zu tun ... vom Ende zu lesen und bis zur Länge der Liste weiter zu dekrementieren, da wir niemals den "End" -Index ausführen und daher auch -1 hinzufügen

Angenommen, die Aufgabe besteht darin, das letzte Element zu finden, das eine bestimmte Bedingung in einer Liste erfüllt (dh zuerst, wenn Sie rückwärts schauen), erhalte ich folgende Zahlen:

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

Die hässlichste Option xrange(len(xs)-1,-1,-1)ist also die schnellste.

Sie können einen Generator verwenden:

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

endlich:

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

hoffe das hilft dir