Der beste Weg, um eine "umgekehrte" Liste in Python zu erstellen?

Was ist in Python der beste Weg, um eine neue Liste zu erstellen, deren Elemente mit denen einer anderen Liste identisch sind, jedoch in umgekehrter Reihenfolge? (Ich möchte die vorhandene Liste nicht ändern.)

Hier ist eine Lösung, die mir eingefallen ist:

new_list = list(reversed(old_list))

Es ist auch möglich, das Duplikat zu duplizieren und old_listdann umzukehren:

new_list = list(old_list) # or `new_list = old_list[:]`
new_list.reverse()

Gibt es eine bessere Option, die ich übersehen habe? Wenn nicht, gibt es einen zwingenden Grund (z. B. Effizienz), einen der oben genannten Ansätze gegenüber dem anderen zu verwenden?

newlist = oldlist[::-1]

Das [::-1]Schneiden (das meine Frau Anna gerne "den Mars-Smiley" nennt ;-) bedeutet: Schneiden Sie die gesamte Sequenz mit einem Schritt von -1, dh umgekehrt. Es funktioniert für alle Sequenzen.

Beachten Sie, dass dies ( und die von Ihnen erwähnten Alternativen) einer "flachen Kopie" entspricht, dh wenn die Elemente veränderlich sind und Sie Mutatoren aufrufen, befinden sich die Mutationen in den Elementen in der ursprünglichen Liste auch in den Elementen in der umgekehrte Liste und umgekehrt. Wenn Sie dies vermeiden müssen, ist a copy.deepcopy(obwohl immer eine potenziell kostspielige Operation), gefolgt von a .reverse, die einzig gute Option.

Jetzt lass uns timeit. Hinweis: Alex [::-1]ist am schnellsten :)

$ p -m timeit "ol = [1, 2, 3]; nl = list(reversed(ol))"
100000 loops, best of 3: 2.34 usec per loop

$ p -m timeit "ol = [1, 2, 3]; nl = list(ol); nl.reverse();"
1000000 loops, best of 3: 0.686 usec per loop

$ p -m timeit "ol = [1, 2, 3]; nl = ol[::-1];"
1000000 loops, best of 3: 0.569 usec per loop

$ p -m timeit "ol = [1, 2, 3]; nl = [i for i in reversed(ol)];"
1000000 loops, best of 3: 1.48 usec per loop


$ p -m timeit "ol = [1, 2, 3]*1000; nl = list(reversed(ol))"
10000 loops, best of 3: 44.7 usec per loop

$ p -m timeit "ol = [1, 2, 3]*1000; nl = list(ol); nl.reverse();"
10000 loops, best of 3: 27.2 usec per loop

$ p -m timeit "ol = [1, 2, 3]*1000; nl = ol[::-1];"
10000 loops, best of 3: 24.3 usec per loop

$ p -m timeit "ol = [1, 2, 3]*1000; nl = [i for i in reversed(ol)];"
10000 loops, best of 3: 155 usec per loop

Update: Die von inspectorG4dget vorgeschlagene List Comp-Methode wurde hinzugefügt. Ich werde die Ergebnisse für sich selbst sprechen lassen.

Anpassungen

Es lohnt sich, einen Basis-Benchmark / eine Basisanpassung für die Timeit-Berechnungen von sdolan bereitzustellen, die die Leistung von "umgekehrt" ohne die oft unnötige list()Konvertierung zeigen. Diese list()Operation fügt der Laufzeit weitere 26 usecs hinzu und wird nur für den Fall benötigt, dass ein Iterator nicht akzeptabel ist.

Ergebnisse:

reversed(lst) -- 11.2 usecs

list(reversed(lst)) -- 37.1 usecs

lst[::-1] -- 23.6 usecs

Berechnungen:

# I ran this set of 100000 and came up with 11.2, twice:
python -m timeit "ol = [1, 2, 3]*1000; nl = reversed(ol)"
100000 loops, best of 3: 11.2 usec per loop

# This shows the overhead of list()
python -m timeit "ol = [1, 2, 3]*1000; nl = list(reversed(ol))"
10000 loops, best of 3: 37.1 usec per loop

# This is the result for reverse via -1 step slices
python -m timeit "ol = [1, 2, 3]*1000;nl = ol[::-1]"
10000 loops, best of 3: 23.6 usec per loop

Schlussfolgerungen:

Der Abschluss dieser Tests ist um 12,4 usecs reversed()schneller als der Slice[::-1]