web-dev-qa-db-de.com

Durchlaufen Sie eine Liste in umgekehrter Reihenfolge in Python

Ich kann also von len(collection) aus starten und mit collection[0] enden.

EDIT: Sorry, ich habe vergessen zu erwähnen, dass ich auch auf den Schleifenindex zugreifen möchte.

553
Joan Venge

Verwenden Sie die integrierte Funktion reversed():

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

So greifen Sie auch auf den ursprünglichen Index zu:

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

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").

137
mipadi

Wenn Sie den Schleifenindex benötigen und die gesamte Liste nicht zweimal durchsuchen 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
63
Triptych

Das kann so gemacht werden:

für i in range (len (collection) -1, -1, -1): 
 print collection [i] 
 
 # print (collection [i]) for python 3. + 
 

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

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

help(range)

54
Alan Rowarth

Die eingebaute Funktion reversed ist praktisch:

for item in reversed(sequence):

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

Für die Fälle, in denen ich mit dem Index eine Sequenz in umgekehrter Reihenfolge ausführen muss (z. B. für In-Place-Modifikationen, bei denen die Sequenzlänge geändert wird), 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),
    )

Dieses vermeidet das Erstellen einer Kopie der Sequenz. Natürlich gelten die Einschränkungen von reversed weiterhin.

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

OR

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

Ich mag den Einliner-Generator-Ansatz:

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

Wie wäre es, ohne eine neue Liste neu zu erstellen?

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

OR

>>> length = len(foo)
>>> for i in range(length):
...     print foo[length-i-1]
...
4d
3c
2b
1a
>>>
5
James Sapam

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

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

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

Sie können auch entweder "Range" - oder "Count" -Funktionen 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 auch "count" von 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
2
disooqi

für was auch immer es sich lohnt, kannst du 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]
2
emorphus

Ein einfacher Ansatz ist:

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

Die anderen Antworten sind gut, aber wenn Sie als Listenverständnisstil

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

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 nicht sicher, warum wir keine Abkürzung dafür haben, zB:

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

oder warum haben wir reversed_range() nicht

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 i - 1, um auf den Index zuzugreifen, als würden Sie vorwärts über eine stornierte Kopie der Sammlung iterieren.

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

Um auf den ursprünglichen, nicht rückgängig gemachten Index zuzugreifen, verwenden Sie 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
Malcolm

Sie können auch eine while-Schleife verwenden:

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

verwenden Sie die integrierte Funktion reversed() für das Sequenzobjekt. Diese Methode wirkt sich auf alle Sequenzen aus

detaillierter Referenzlink

1
lazybios
a = ["foo", "bar", "baz"]
print a[::~0]

ein weiterer Weg, um dieses Problem zu lösen, ist die dekrementierte Ausführung dieses Codes für die Schleife

1
paras chauhan

die umgekehrte Funktion ist hier hilfreich:

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

Wenn Sie den Index benötigen, können Sie am einfachsten den von enumerate(reversed()) zurückgegebenen Index von len()-1 abziehen. enumerate() nimmt kein step-Argument an. 

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

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

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)

oder wenn Sie es nur einmal tun müssen:

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

    do_something(index, value)
0
Boris

Angenommen, es gilt, das letzte Element zu finden, das eine Bedingung in einer Liste erfüllt (d. H. Zuerst beim Rückblick), ich bekomme 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.

0
wonder.mice

Negative Indizes verwenden: Beginnen Sie bei -1 und gehen Sie bei jeder Wiederholung 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
0
stroz
input_list = ['foo','bar','baz']
for i in range(-1,-len(input_list)-1,-1)
    print(input_list[i])

ich denke, dies ist auch ein einfacher Weg, um es zu tun ... von Ende lesen und bis zur Länge der Liste weiter dekrementieren, da wir niemals den "End" -Index ausführen, also -1 hinzugeben

0
Varun Maurya

Ich denke, der eleganteste Weg ist, enumerate und reversed mit dem folgenden Generator zu transformieren

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

dies erzeugt eine Umkehrung des Iterators enumerate

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]
0
CervEd

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

Wenn Sie nichts dagegen haben, 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
0
jss367