Wie kann ich in Python Folgendes tun?

array = [0, 10, 20, 40]
for (i = array.length() - 1; i >= 0; i--)

Ich muss die Elemente eines Arrays haben, aber vom Ende bis zum Anfang.

Sie können die reversedFunktion hierfür wie folgt nutzen :

>>> array=[0,10,20,40]
>>> for i in reversed(array):
...     print(i)

Beachten Sie, dass reversed(...)keine Liste zurückgegeben wird. Sie können eine umgekehrte Liste mit erhalten list(reversed(array)).

>>> L = [0,10,20,40]
>>> L[::-1]
[40, 20, 10, 0]

Die erweiterte Slice-Syntax wird im Python Was ist neuer Eintrag für die Veröffentlichung?2.3.5

Auf besonderen Wunsch in einem Kommentar ist dies die aktuellste Slice-Dokumentation .

>>> L = [0,10,20,40]
>>> L.reverse()
>>> L
[40, 20, 10, 0]

Oder

>>> L[::-1]
[40, 20, 10, 0]

Dies dient zum Duplizieren der Liste:

L = [0,10,20,40]
p = L[::-1]  #  Here p will be having reversed list

Dies dient zum Umkehren der Liste an Ort und Stelle:

L.reverse() # Here L will be reversed in-place (no new list made)

Ich denke, dass der beste Weg, eine Liste in Python umzukehren, darin besteht, Folgendes zu tun:

a = [1,2,3,4]
a = a[::-1]
print(a)
>>> [4,3,2,1]

Die Arbeit ist erledigt, und jetzt haben Sie eine umgekehrte Liste.

Verwenden Sie zum Umkehren derselben Liste:

array.reverse()

Um eine umgekehrte Liste einer anderen Liste zuzuweisen, verwenden Sie:

newArray = array[::-1] 

Das Schneiden, z. B. array = array [:: - 1], ist ein ordentlicher Trick und sehr pythonisch, aber für Neulinge vielleicht etwas dunkel. Die Verwendung der reverse () -Methode ist ein guter Weg für die tägliche Codierung, da sie leicht lesbar ist.

Wenn Sie jedoch eine Liste wie in einer Interviewfrage umkehren müssen, können Sie wahrscheinlich keine integrierten Methoden wie diese verwenden. Der Interviewer wird sich eher mit der Herangehensweise an das Problem als mit der Tiefe des Python-Wissens befassen. Ein algorithmischer Ansatz ist erforderlich. Das folgende Beispiel mit einem klassischen Swap könnte eine Möglichkeit sein: -

def reverse_in_place(lst):      # Declare a function
    size = len(lst)             # Get the length of the sequence
    hiindex = size - 1
    its = size/2                # Number of iterations required
    for i in xrange(0, its):    # i is the low index pointer
        temp = lst[hiindex]     # Perform a classic swap
        lst[hiindex] = lst[i]
        lst[i] = temp
        hiindex -= 1            # Decrement the high index pointer
    print "Done!"

# Now test it!!
array = [2, 5, 8, 9, 12, 19, 25, 27, 32, 60, 65, 1, 7, 24, 124, 654]

print array                    # Print the original sequence
reverse_in_place(array)        # Call the function passing the list
print array                    # Print reversed list


**The result:**
[2, 5, 8, 9, 12, 19, 25, 27, 32, 60, 65, 1, 7, 24, 124, 654]
Done!
[654, 124, 24, 7, 1, 65, 60, 32, 27, 25, 19, 12, 9, 8, 5, 2]

Beachten Sie, dass dies bei Tupeln oder Zeichenfolgenfolgen nicht funktioniert, da Zeichenfolgen und Tupel unveränderlich sind, dh Sie können nicht in sie schreiben, um Elemente zu ändern.

Ich finde (im Gegensatz zu einigen anderen Vorschlägen), dass dies l.reverse()bei weitem der schnellste Weg ist, eine lange Liste in Python 3 und 2 umzukehren. Es würde mich interessieren, ob andere diese Timings replizieren können.

l[::-1]ist wahrscheinlich langsamer, da die Liste vor dem Umkehren kopiert wird. Das Hinzufügen des list()Aufrufs um den Iterator von reversed(l)muss zusätzlichen Aufwand verursachen. Wenn Sie eine Kopie der Liste oder einen Iterator wünschen, verwenden Sie natürlich die entsprechenden Methoden. Wenn Sie die Liste jedoch nur umkehren möchten, l.reverse()scheint dies der schnellste Weg zu sein.

Funktionen

def rev_list1(l):
    return l[::-1]

def rev_list2(l):
    return list(reversed(l))

def rev_list3(l):
    l.reverse()
    return l

Liste

l = list(range(1000000))

Python 3.5-Timings

timeit(lambda: rev_list1(l), number=1000)
# 6.48
timeit(lambda: rev_list2(l), number=1000)
# 7.13
timeit(lambda: rev_list3(l), number=1000)
# 0.44

Python 2.7 Timings

timeit(lambda: rev_list1(l), number=1000)
# 6.76
timeit(lambda: rev_list2(l), number=1000)
# 9.18
timeit(lambda: rev_list3(l), number=1000)
# 0.46

for x in array[::-1]:
    do stuff

Mit reversedund list:

>>> list1 = [1,2,3]
>>> reversed_list = list(reversed(list1))
>>> reversed_list
>>> [3, 2, 1]

array=[0,10,20,40]
for e in reversed(array):
  print e

Die Verwendung von umgekehrt (Array) wäre die wahrscheinlich beste Route.

>>> array = [1,2,3,4]
>>> for item in reversed(array):
>>>     print item

Sollten Sie verstehen müssen, wie dies implementiert werden kann, ohne das eingebaute zu verwenden reversed.

def reverse(a):
    midpoint = len(a)/2
    for item in a[:midpoint]:
        otherside = (len(a) - a.index(item)) - 1
        temp = a[otherside]
        a[otherside] = a[a.index(item)]
        a[a.index(item)] = temp
    return a

Dies sollte O (N) Zeit dauern.

Zusammenfassung der Methoden mit Erläuterungs- und Timing-Ergebnissen

Es gibt mehrere gute Antworten, die jedoch verteilt sind und die meisten zeigen nicht die grundlegenden Unterschiede der einzelnen Ansätze auf.

Insgesamt ist es besser, integrierte Funktionen / Methoden zum Umkehren zu verwenden, wie bei nahezu jeder Funktion. In diesem Fall sind sie auf kurzen Listen (10 Elemente) ungefähr zwei- bis achtmal schneller und auf langen Listen bis zu 300-mal schneller als auf manuell erstellten Indizierungsmitteln. Dies ist sinnvoll, da sie von Experten erstellt, geprüft und optimiert werden. Sie sind auch weniger anfällig für Defekte und eher für Kanten- und Eckfälle geeignet.

Überlegen Sie auch, ob Sie:

1. Kehren Sie eine vorhandene Liste an Ort und Stelle um
   • Beste Lösung ist object.reverse()Methode
2. Erstellen Sie einen Iterator auf der Rückseite der Liste (da Sie ihn einer for-Schleife, einem Generator usw. zuführen werden).
   • Die beste Lösung ist reversed(object), den Iterator zu erstellen
3. oder erstellen Sie eine vollständige Kopie in umgekehrter Reihenfolge
   • Die beste Lösung ist die Verwendung von Scheiben mit einer Schrittgröße von -1: object[::-1]

Testskript

Hier ist der Beginn meines Testskripts für die behandelten Methoden. Fügen Sie alle Codefragmente in dieser Antwort zusammen, um ein Skript zu erstellen, das alle verschiedenen Möglichkeiten zum Umkehren einer Liste und der Uhrzeit ausführt (Ausgabe im letzten Abschnitt).

from timeit import timeit
from copy import copy

def time_str_ms(t):
    return '{0:8.2f} ms'.format(t * 1000)

Methode 1: Mit obj.reverse () umkehren

Wenn das Ziel nur darin besteht, die Reihenfolge der Elemente in einer vorhandenen Liste umzukehren, ohne sie zu durchlaufen oder eine Kopie zum Arbeiten zu erhalten, verwenden Sie die <list>.reverse()Funktion. Führen Sie dies direkt auf einem Listenobjekt aus, und die Reihenfolge aller Elemente wird umgekehrt:

Beachten Sie, dass im Folgenden die angegebene ursprüngliche Variable umgekehrt wird, obwohl auch die umgekehrte Liste zurückgegeben wird. dh Sie können mit dieser Funktionsausgabe eine Kopie erstellen. Normalerweise würden Sie dafür keine Funktion erstellen, aber ich habe dies getan, um den Timing-Code am Ende zu verwenden.

Wir werden die Leistung dieser beiden Methoden testen - zuerst eine Liste an Ort und Stelle umkehren (die ursprüngliche Liste ändern), dann die Liste kopieren und anschließend umkehren.

def rev_in_place(mylist):
    mylist.reverse()
    return mylist

def rev_copy_reverse(mylist):
    a = copy(mylist)
    a.reverse()
    return a

Methode 2: Kehren Sie eine Liste mit Slices um obj[::-1]

Mit der integrierten Index-Slicing-Methode können Sie eine Kopie eines Teils eines indizierten Objekts erstellen.

• Das ursprüngliche Objekt ist davon nicht betroffen
• Es wird eine vollständige Liste erstellt, kein Iterator

Die generische Syntax lautet : <object>[first_index:last_index:step]. Verwenden Sie Folgendes, um das Slicing zum Erstellen einer einfachen umgekehrten Liste zu nutzen <list>[::-1]. Wenn Sie eine Option leer lassen, werden sie auf die Standardeinstellungen des ersten und letzten Elements des Objekts gesetzt (umgekehrt, wenn die Schrittgröße negativ ist).

Durch die Indizierung können negative Zahlen verwendet werden, die ab dem Ende des Objektindex rückwärts zählen (dh -2 ist das vorletzte Element). Wenn die Schrittgröße negativ ist, beginnt sie mit dem letzten Element und indiziert um diesen Betrag rückwärts. Damit ist eine Start-End-Logik verbunden, die optimiert wurde.

def rev_slice(mylist):
    a = mylist[::-1]
    return a

Methode 3: Kehren Sie eine Liste mit der reversed(obj)Iteratorfunktion um

Es gibt eine reversed(indexed_object)Funktion:

• Dadurch wird ein Reverse-Index-Iterator erstellt, keine Liste. Großartig, wenn Sie es einer Schleife zuführen, um eine bessere Leistung bei großen Listen zu erzielen
• Dies erstellt eine Kopie und wirkt sich nicht auf das Originalobjekt aus

Testen Sie mit einem rohen Iterator und erstellen Sie eine Liste aus dem Iterator.

def reversed_iterator(mylist):
    a = reversed(mylist)
    return a

def reversed_with_list(mylist):
    a = list(reversed(mylist))
    return a

Methode 4: Liste mit benutzerdefinierter / manueller Indizierung umkehren

Wie das Timing zeigen wird, ist es eine schlechte Idee, eigene Indizierungsmethoden zu erstellen. Verwenden Sie die integrierten Methoden, es sei denn, Sie müssen etwas wirklich Benutzerdefiniertes tun.

Das heißt, es gibt keine große Strafe bei kleineren Listengrößen, aber wenn Sie skalieren, wird die Strafe enorm. Ich bin sicher, dass mein Code unten optimiert werden könnte, aber ich werde mich an die integrierten Methoden halten.

def rev_manual_pos_gen(mylist):
    max_index = len(mylist) - 1
    return [ mylist[max_index - index] for index in range(len(mylist)) ]

def rev_manual_neg_gen(mylist):
    ## index is 0 to 9, but we need -1 to -10
    return [ mylist[-index-1] for index in range(len(mylist)) ]

def rev_manual_index_loop(mylist):
    a = []
    reverse_index = len(mylist) - 1
    for index in range(len(mylist)):
        a.append(mylist[reverse_index - index])
    return a

def rev_manual_loop(mylist):
    a = []
    reverse_index = len(mylist)
    for index, _ in enumerate(mylist):
        reverse_index -= 1
        a.append(mylist[reverse_index])
    return a

Timing jeder Methode

Im Folgenden finden Sie den Rest des Skripts, um die Zeit für jede Umkehrmethode festzulegen. Es zeigt, dass das Umkehren an Ort obj.reverse()und Stelle mit und das Erstellen des reversed(obj)Iterators immer am schnellsten sind, während die Verwendung von Slices der schnellste Weg ist, um eine Kopie zu erstellen.

Es erweist sich auch als nicht zu versuchen, einen Weg zu finden, dies selbst zu tun, es sei denn, Sie müssen!

loops_to_test = 100000
number_of_items = 10
list_to_reverse = list(range(number_of_items))
if number_of_items < 15:
    print("a: {}".format(list_to_reverse))
print('Loops: {:,}'.format(loops_to_test))
# List of the functions we want to test with the timer, in print order
fcns = [rev_in_place, reversed_iterator, rev_slice, rev_copy_reverse,
        reversed_with_list, rev_manual_pos_gen, rev_manual_neg_gen,
        rev_manual_index_loop, rev_manual_loop]
max_name_string = max([ len(fcn.__name__) for fcn in fcns ])
for fcn in fcns:
    a = copy(list_to_reverse) # copy to start fresh each loop
    out_str = ' | out = {}'.format(fcn(a)) if number_of_items < 15 else ''
    # Time in ms for the given # of loops on this fcn
    time_str = time_str_ms(timeit(lambda: fcn(a), number=loops_to_test))
    # Get the output string for this function
    fcn_str = '{}(a):'.format(fcn.__name__)
    # Add the correct string length to accommodate the maximum fcn name
    format_str = '{{fx:{}s}} {{time}}{{rev}}'.format(max_name_string + 4)
    print(format_str.format(fx=fcn_str, time=time_str, rev=out_str))

Timing-Ergebnisse

Die Ergebnisse zeigen, dass die Skalierung am besten mit den integrierten Methoden funktioniert, die für eine bestimmte Aufgabe am besten geeignet sind. Mit anderen Worten, wenn die Anzahl der Objektelemente zunimmt, beginnen die integrierten Methoden, weit überlegene Leistungsergebnisse zu erzielen.

Sie sind auch besser dran, wenn Sie die beste integrierte Methode verwenden, mit der Sie direkt das erreichen, was Sie benötigen, als Dinge aneinander zu reihen. Das heißt, das Schneiden ist am besten, wenn Sie eine Kopie der umgekehrten Liste benötigen - es ist schneller als das Erstellen einer Liste aus der reversed()Funktion und schneller als das Erstellen einer Kopie der Liste und das anschließende Ausführen obj.reverse(). Aber wenn eine dieser Methoden wirklich alles ist, was Sie brauchen, sind sie schneller, aber niemals mehr als doppelt so schnell. In der Zwischenzeit können benutzerdefinierte manuelle Methoden um Größenordnungen länger dauern, insbesondere bei sehr großen Listen.

Für die Skalierung mit einer Liste mit 1000 Elementen reversed(<list>)dauert der Funktionsaufruf ~ 30 ms, um den Iterator einzurichten. Das Umkehren an Ort und Stelle dauert nur ~ 55 ms. Bei Verwendung der Slice-Methode dauert es ~ 210 ms, um eine Kopie der vollständigen umgekehrten Liste zu erstellen Die schnellste manuelle Methode, die ich gemacht habe, dauerte ~ 8400 ms !!

Mit 2 Elementen in der Liste:

a: [0, 1]
Loops: 100,000
rev_in_place(a):             24.70 ms | out = [1, 0]
reversed_iterator(a):        30.48 ms | out = <list_reverseiterator object at 0x0000020242580408>
rev_slice(a):                31.65 ms | out = [1, 0]
rev_copy_reverse(a):         63.42 ms | out = [1, 0]
reversed_with_list(a):       48.65 ms | out = [1, 0]
rev_manual_pos_gen(a):       98.94 ms | out = [1, 0]
rev_manual_neg_gen(a):       88.11 ms | out = [1, 0]
rev_manual_index_loop(a):    87.23 ms | out = [1, 0]
rev_manual_loop(a):          79.24 ms | out = [1, 0]

Mit 10 Elementen in der Liste:

rev_in_place(a):             23.39 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
reversed_iterator(a):        30.23 ms | out = <list_reverseiterator object at 0x00000290A3CB0388>
rev_slice(a):                36.01 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_copy_reverse(a):         64.67 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
reversed_with_list(a):       50.77 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_pos_gen(a):      162.83 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_neg_gen(a):      167.43 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_index_loop(a):   152.04 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
rev_manual_loop(a):         183.01 ms | out = [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Und mit 1000 Artikeln in der Liste:

rev_in_place(a):             56.37 ms
reversed_iterator(a):        30.47 ms
rev_slice(a):               211.42 ms
rev_copy_reverse(a):        295.74 ms
reversed_with_list(a):      418.45 ms
rev_manual_pos_gen(a):     8410.01 ms
rev_manual_neg_gen(a):    11054.84 ms
rev_manual_index_loop(a): 10543.11 ms
rev_manual_loop(a):       15472.66 ms

Wenn Sie die Elemente der umgekehrten Liste in einer anderen Variablen speichern möchten, können Sie revArray = array[::-1]oder verwenden revArray = list(reversed(array)).

Die erste Variante ist aber etwas schneller:

z = range(1000000)
startTimeTic = time.time()
y = z[::-1]
print("Time: %s s" % (time.time() - startTimeTic))

f = range(1000000)
startTimeTic = time.time()
g = list(reversed(f))
print("Time: %s s" % (time.time() - startTimeTic))

Ausgabe:

Time: 0.00489711761475 s
Time: 0.00609302520752 s

ORGANISIEREN VON WERTEN:

In Python kann auch die Reihenfolge der Listen durch Sortieren geändert werden, wobei Ihre Variablen in numerischer / alphabetischer Reihenfolge angeordnet werden:

Vorübergehend:

print(sorted(my_list))

Dauerhaft:

my_list.sort(), print(my_list)

Sie können mit dem Flag "reverse = True" sortieren :

print(sorted(my_list, reverse=True))

oder

my_list.sort(reverse=True), print(my_list)

OHNE ORGANISIEREN

Vielleicht möchten Sie keine Werte sortieren, sondern nur die Werte umkehren. Dann können wir es so machen:

print(list(reversed(my_list)))

** Zahlen haben in der Reihenfolge der Auflistung Vorrang vor dem Alphabet. Die Organisation der Python-Werte ist fantastisch.

Mit etwas Logik

Verwenden Sie eine Logik der alten Schule, um Interviews zu üben.

Nummern von vorne nach hinten tauschen. Verwenden von zwei Zeigernindex[0] and index[last]

def reverse(array):
    n = array
    first = 0
    last = len(array) - 1
    while first < last:
      holder = n[first]
      n[first] = n[last]
      n[last] = holder
      first += 1
      last -= 1
    return n

input -> [-1 ,1, 2, 3, 4, 5, 6]
output -> [6, 1, 2, 3, 4, 5, -1]

Sie können auch das bitweise Komplement des Array-Index verwenden, um das Array in umgekehrter Reihenfolge zu durchlaufen:

>>> array = [0, 10, 20, 40]
>>> [array[~i] for i, _ in enumerate(array)]
[40, 20, 10, 0]

Was auch immer Sie tun, tun Sie es nicht so.

Listenverständnis verwenden:

[array[n] for n in range(len(array)-1, -1, -1)]

Eine andere Lösung wäre, hierfür numpy.flip zu verwenden

import numpy as np
array = [0, 10, 20, 40]
list(np.flip(array))
[40, 20, 10, 0]

Genau genommen lautet die Frage nicht, wie eine Liste umgekehrt zurückgegeben werden soll, sondern wie eine Liste mit einem Beispiellistennamen umgekehrt werden soll array.

Um eine Liste mit dem Namen "array"use umzukehren array.reverse().

Die beschriebene unglaublich nützliche Slice-Methode kann auch verwendet werden, um eine Liste an Ort und Stelle umzukehren, indem die Liste als eine in Scheiben geschnittene Modifikation von sich selbst definiert wird array = array[::-1].

def reverse(text):
    output = []
    for i in range(len(text)-1, -1, -1):
        output.append(text[i])
    return output

Mit minimaler Anzahl integrierter Funktionen, vorausgesetzt, es handelt sich um Intervieweinstellungen

array = [1, 2, 3, 4, 5, 6,7, 8]
inverse = [] #create container for inverse array
length = len(array)  #to iterate later, returns 8 
counter = length - 1  #because the 8th element is on position 7 (as python starts from 0)

for i in range(length): 
   inverse.append(array[counter])
   counter -= 1
print(inverse)

Die direkteste Übersetzung Ihrer Anforderung in Python ist diese forAussage:

for i in xrange(len(array) - 1, -1, -1):
   print i, array[i]

Dies ist ziemlich kryptisch, kann aber nützlich sein.

def reverse(my_list):
  L = len(my_list)
  for i in range(L/2):
    my_list[i], my_list[L-i - 1] = my_list[L-i-1], my_list[i]
  return my_list

Sie können die Liste jederzeit wie einen Stapel behandeln, indem Sie die Elemente vom hinteren Ende der Liste oben auf den Stapel legen. Auf diese Weise nutzen Sie die First-In-Last-Out-Eigenschaften eines Stapels. Natürlich verbrauchen Sie das 1. Array. Ich mag diese Methode, weil sie ziemlich intuitiv ist, da Sie sehen, dass eine Liste vom Back-End verwendet wird, während die andere vom Front-End erstellt wird.

>>> l = [1,2,3,4,5,6]; nl=[]
>>> while l:
        nl.append(l.pop())  
>>> print nl
[6, 5, 4, 3, 2, 1]

list_data = [1,2,3,4,5]
l = len(list_data)
i=l+1
rev_data = []
while l>0:
  j=i-l
  l-=1
  rev_data.append(list_data[-j])
print "After Rev:- %s" %rev_data 

verwenden

print(reversed(list_name))

Hier ist eine Möglichkeit, das Gegenteil mithilfe eines Generators träge zu bewerten :

def reverse(seq):
    for x in range(len(seq), -1, -1): #Iterate through a sequence starting from -1 and increasing by -1.
        yield seq[x] #Yield a value to the generator

Jetzt iterieren Sie wie folgt durch:

for x in reverse([1, 2, 3]):
    print(x)

Wenn Sie eine Liste benötigen:

l = list(reverse([1, 2, 3]))

Es gibt 3 Methoden, um die umgekehrte Liste zu erhalten:

1. Schneidemethode 1: reversed_array = array[-1::-1]

2. Schneidemethode 2: reversed_array2 = array[::-1]

3. Verwenden der integrierten Funktion: reversed_array = array.reverse()

Die dritte Funktion kehrte das vorhandene Listenobjekt tatsächlich um. Das bedeutet, dass keine Kopie der ursprünglichen Daten beibehalten wird. Dies ist ein guter Ansatz, wenn Sie die alte Version nicht beibehalten möchten. Aber scheint keine Lösung zu sein, wenn Sie die makellose und umgekehrte Version wollen.

>>> l = [1, 2, 3, 4, 5]
>>> print(reduce(lambda acc, x: [x] + acc, l, []))
[5, 4, 3, 2, 1]