im folgenden Beispiel:
foo = ['red', 'white', 'blue', 1, 2, 3]
Dabei foo[0:6:1]werden alle Elemente in foo gedruckt. Das foo[6:0:-1]1. oder 0. Element wird jedoch weggelassen.
>>> foo[6:0:-1]
[3, 2, 1, 'blue', 'white']
Ich verstehe, dass ich foo.reverse () oder foo [:: - 1] verwenden kann, um die Liste in umgekehrter Reihenfolge zu drucken, aber ich versuche zu verstehen, warum foo [6: 0: -1] nicht die gesamte Liste druckt ?
Antworten:
Kurznotiz:
[ <first element to include> : <first element to exclude> : <step> ]
Wenn Sie das erste Element beim Umkehren einer Liste einschließen möchten, lassen Sie das mittlere Element wie folgt leer:
foo[::-1]
Hier finden Sie auch einige gute Informationen zu Python-Slices im Allgemeinen:
Erläutern Sie die Slice-Notation von Python
[ <first element to include> : <first element to exclude> : <step> ]ist die klarste Erklärung für die Slice-Syntax, die ich gesehen habe. Wenn man es "erstes auszuschließendes Element" nennt, wird wirklich klar, was los ist.
<first element to include>oder als Index <first element to exclude>am Ende der Liste verwenden, -1ist dies auch das letzte Element, -2das vorletzte Element usw. So x[-1:-4:-1]würden beispielsweise die letzten drei Elemente xin umgekehrter Reihenfolge abgerufen. Sie können dies also so interpretieren, dass Sie "rückwärts gehen und jedes Element ( -1Schritt) vom letzten Element in der Liste ( -1 <first element to include>) bis zum vierten Element vom Ende ( -4 <first element to include>) nehmen, aber nicht einbeziehen ".
<step>ja -1) hilft es mir zu denken <first element to include, moving from right to left>. So erhalten Sie die nElemente "ganz links" aus einer Liste in umgekehrter Reihenfolge : foo[n-1::-1]. So erhalten Sie die nElemente "ganz rechts" in umgekehrter Reihenfolge : foo[-1:-n-1:-1].
foo[0]" ausschließt?
Wenn Sie Probleme haben, sich an die Slice-Notation zu erinnern, können Sie versuchen, den Hokey Cokey auszuführen :
[ In : Out : Schütteln Sie alles über ]
[Erstes Element in clude: Erstes Element zu verlassen out : Der Schritt zur Verwendung]
YMMV
... warum druckt foo [6: 0: -1] nicht die gesamte Liste?
Weil der Mittelwert eher der exklusive als der inklusive Stoppwert ist. Die Intervallnotation lautet [Start, Stopp].
Genau so funktioniert der [x] -Bereich:
>>> range(6, 0, -1)
[6, 5, 4, 3, 2, 1]
Dies sind die Indizes, die in Ihre resultierende Liste aufgenommen werden, und sie enthalten keine 0 für das erste Element.
>>> range(6, -1, -1)
[6, 5, 4, 3, 2, 1, 0]
Eine andere Sichtweise ist:
>>> L = ['red', 'white', 'blue', 1, 2, 3]
>>> L[0:6:1]
['red', 'white', 'blue', 1, 2, 3]
>>> len(L)
6
>>> L[5]
3
>>> L[6]
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
Der Index 6 liegt jenseits (genau eins) der gültigen Indizes für L und schließt ihn daher als ausgeschlossenen Stoppwert aus dem Bereich aus:
>>> range(0, 6, 1)
[0, 1, 2, 3, 4, 5]
Gibt Ihnen weiterhin Indizes für jedes Element in der Liste.
rangekann es, aber Slice kann es nicht, weil -1es das letzte Element ist. Also l=[1, 2, 3], l[2:-1:-1] == [].
Diese Antwort mag etwas veraltet sein, aber sie könnte für jemanden hilfreich sein, der an demselben Problem festhält. Sie können eine umgekehrte Liste mit einem beliebigen Ende erhalten - bis zu 0 Index, indem Sie das zweite In-Place-Slice wie folgt anwenden:
>>> L = list(range(10))
>>> L
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> (start_ex, end) = (7, 0)
>>> L[end:start_ex][::-1]
[6, 5, 4, 3, 2, 1, 0]
Verwenden
>>>foo[::-1]
Dies zeigt die Umkehrung der Liste vom Endelement bis zum Start an.
Ergänzen. Schritt um 2 umkehren:
A = [1,2,2,3,3]
n = len(A)
res = [None] * n
mid = n//2 + 1 if n%2 == 1 else n//2
res[0::2] = A[0:mid][::-1]
res[1::2] = A[0:mid][::-1]
print(res)
[2, 3, 2, 3, 1]
Die Antwort von Andrew Clark ein bisschen mehr formalisieren :
Angenommen, die Liste vund das v[n1:n2:n3]Slice.
n1ist Anfangsposition, n2ist Endposition und n3ist Schritt
Schreiben wir einen Pseucode auf Python-Weise:
n3 = 1 if (n3 is missing) else n3
if n3==0:
raise exception # error, undefined step
Erster Teil: n3 positiv
if n3>0:
slice direction is from left to right, the most common direction
n1 is left slice position in `v`
if n1 is missing:
n1 = 0 # initial position
if n1>=0:
n1 is a normal position
else:
(-n1-1) is the position in the list from right to left
n2 is right slice position in `v`
if n2 is missing:
n2 = len(x) # after final position
if n2>=0:
n2 is a normal final position (exclusive)
else:
-n2-1 é the final position in the list from right to left
(exclusive)
Zweiter Teil: n3 negativ
else:
slice direction is from right to left (inverse direction)
n1 is right slice position in `v`
if n1 is missing:
n1 = -1 # final position is last position in the list.
if n1>=0:
n1 is a normal position
else:
(-n1-1) is the position in the list from right to left
n2 is left slice position in `v`
if n2 is missing:
n2 = -len(x)-1 # before 1st character (exclusive)
if n2>=0:
n2 is a normal final position (exclusive)
else:
-n2-1 is the ending position in the list from right to left
(exclusive)
Nun das ursprüngliche Problem: Wie kann man eine Liste mit Slice-Notation umkehren?
L = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(L(::-1)) # [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
Warum?
n1 is missing and n3<0 => n1=0
n2 is missing and n3<0 => n2 = -len(x)-1
Damit L(::-1) == L(-1:-11:-1)
foo[7:None:-1]Möglichkeit :)