Umkehren einer Liste mit Slice-Notation

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 ?

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

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.

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.

Sie können es zum Laufen bringen, wenn Sie einen negativen Stoppwert verwenden. Versuche dies:

foo[-1:-7:-1]

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)