Wie zerlegt man eine Liste, einen String oder ein Tupel – Teil 1

In Python kann man mit Hilfe eines Slice (z. B. [2:5:2]) Teilsequenzen aus Sequenzobjekten wie Listen, Strings, Tupeln usw. extrahieren.

Grundlegende Verwendung von Slices

[start:stop]

In einem Slice werden die start- und stop-Positionen für die Teilsequenz als [start:stop] bezeichnet. Der extrahierte Bereich ist start <= x < stop, einschließlich des Elements am Start, aber ausschließlich des Elements am Stopp.

Beispiel

l = [0, 10, 20, 30, 40, 50, 60]

print(l[2:5])
# [20, 30, 40]

Man kann sich die Positionen (Indizes) für das Slice als Zeiger zwischen den Elementen vorstellen.

Beispiel

 +---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1

In diesem Beispiel werden Slices für Zeichenketten gezeigt, aber das gleiche Konzept gilt für Listen, Tupel und andere Sequenzobjekte. Der Fall von negativen Werten wird später beschrieben.

Das Weglassen von start extrahiert die Teilsequenz vom Anfang an, während das Weglassen von stop sie bis zum Ende extrahiert. Wenn beide weggelassen werden, werden alle Elemente extrahiert.

l = [0, 10, 20, 30, 40, 50, 60]

print(l[:3])
# [0, 10, 20]

print(l[3:])
# [30, 40, 50, 60]

print(l[:])
# [0, 10, 20, 30, 40, 50, 60]

Wert außerhalb des Bereichs (out of range)

Es tritt kein Fehler auf, wenn man eine Position angibt, die die Anzahl der Positionen überschreitet.

print(l[2:10])
# [20, 30, 40, 50, 60]

Wenn kein Element ausgewählt ist

Es tritt kein Fehler auf, wenn man start und stop angibt, die kein Element auswählen. Es wird eine leere Liste zurückgegeben.

print(l[5:2])
# []

print(l[2:2])
# []

print(l[10:20])
# []

[start:stop:step]

Man kann zusätzlich zu start und stop einen step (Schrittweite) als [start:stop:step] angeben. Wenn beispielsweise Step auf 2 eingestellt ist, kann man Elemente an ungeraden oder geraden Positionen auswählen.

Beipiele

l = [0, 10, 20, 30, 40, 50, 60]

print(l[::2])
# [0, 20, 40, 60]

print(l[1::2])
# [10, 30, 50]

weitere Beipiele

print(l[::3])
# [0, 30, 60]

print(l[2:5:2])
# [20, 40]

Wie in den vorangegangenen Beispielen wird der Wert 1 gesetzt, wenn Step nicht verwendet wird.

Extrahieren mit negativen Wert

Negative Werte für start und stop

Negative Werte für start und stop stehen für Positionen ab dem Ende.

Das Konzept der Positionen (Indizes) für das Slice wird im Folgenden noch einmal erläutert.

 +---+---+---+---+---+---+
| P | y | t | h | o | n |
+---+---+---+---+---+---+
0 1 2 3 4 5 6
-6 -5 -4 -3 -2 -1

l = [0, 10, 20, 30, 40, 50, 60]

print(l[3:-1])
# [30, 40, 50]

print(l[-2:])
# [50, 60]

print(l[-5:-2])
# [20, 30, 40]

Negative Werte für step

Wenn Schritt ein negativer Wert ist, werden die Positionen in umgekehrter Reihenfolge ausgewählt.

Die Elemente werden ab der Position bei start ausgewählt. Wenn start keine Position nach stop angibt, ist das Ergebnis leer.

Beispiele

l = [0, 10, 20, 30, 40, 50, 60]

print(l[5:2:-1])
# [50, 40, 30]

print(l[2:5:-1])
# []

print(l[-2:-5:-1])
# [50, 40, 30]

print(l[-2:2:-1])
# [50, 40, 30]

print(l[5:2:-2])
# [50, 30]

Wenn step ein negativer Wert ist, wird bei Weglassen von start vom Ende und bei Weglassen von stop vom Anfang an ausgewählt. Wenn beide weggelassen werden, werden alle Objekte ausgewählt.

Wenn man start und stop weglässt und step auf -1 setzt, kann man ein umgekehrtes Objekt erhalten.

print(l[:3:-1])
# [60, 50, 40]

print(l[3::-1])
# [30, 20, 10, 0]

print(l[::-1])
# [60, 50, 40, 30, 20, 10, 0]

Man kann auch reverse() und reversed() verwenden, um Listen oder Zeichenketten, Tupel usw. umzukehren.str