Skip to content

Wie man eine Liste, einen String oder ein Tupel in Python zerlegt

Python

In Python mit einem Slice (z. B.:[2:5:2]), you can extract a subsequence of a sequence object, such as a list, string, tuple, etc.

Dieser Artikel hat folgenden Inhalt.

  • Grundlegende Verwendung von Slices
    • [Start stop]
    • [Start:Stopp:Schritt]
  • Extrahieren Sie am Ende mit einem negativen Wert
    • Negative Werte für Start und Stopp
    • Negative Werte für Schritt
  • Slice Objekt für Slice()
  • Werte nach Slices zuweisen
  • Slices für eine Liste von Listen
  • Slices machen eine flache Kopie
  • Slices für Streicher und Tupel

Grundlegende Verwendung von Slices

[Start stop]

In einem Slice werden die Startposition start und die Endposition stop der Teilsequenz als [start:stop] geschrieben.

Der Bereich beginnt <= x

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

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

Sie können sich sterben Positionen (Indizes) für das Slice so vorstellen, als ob sie zwischen Elementen zeigen.

Eine Möglichkeit, sich daran zu erinnern, wie Slices funktionieren, besteht darin, sich die Indizes so vorzustellen, dass sie zwischen Zeichen zeigen, wobei die linke Kante des ersten Zeichens mit 0 nummeriert IST.
3. Eine informelle Einführung in Python – Strings — Dokumentation zu Python 3.10.4

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

Das Obige ist ein Beispiel für Streicher, aber dasselbe gilt für Listen, Tupel usw. Der Fall von negativen Werten wird später beschrieben.

If start weggelassen WIRD, WIRD sterben Teilsequenz vom Anfang an gesichert, und wenn stop weggelassen WIRD, WIRD sterben Teilsequenz bis zum Ende gesichert. Wenn beide weggelassen Werden, Werden alle Elemente extrahiert.

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

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

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

Außer Reichweite

Es WIRD kein Fehler ausgelöst, WENN SIE Eine Position angeben, sterben sterben Anzahl der Elemente überschreiten.

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

Wenn kein Element ausgewählt ist

Es WIRD kein Fehler ausgelöst, wenn Sie Start und Stopp angeben, sterben kein Element auswählen. Es wird eine leere Liste zurückgegeben.

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

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

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

[Start:Stopp:Schritt]

Zusätzlich zu Startposition Start und Endposition Stopp können Sie Schritt als [Start:Stopp:Schritt] angeben.

Wenn Schritt beispielsweise auf 2 eingestellt ist, können Elemente an ungeradzahligen oder geradzahligen Positionen ausgewählt werden.

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

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

Andere Beispiele:

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

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

Wie in den bisherigen Beispielen wird step auf 1 gesetzt, wenn step weggelassen wird.

Negative Werte für Start und Stopp

Werden Start und Stop mit negativen Werten angegeben, gelten sie als Positionen vom Ende.

-1 gibt das letzte Element an.

If stop=-1 IST, WIRD das Element bei stop nicht eingeschlossen, sodass der zweite Wert vom Ende ausgewählt WIRD.

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

Das Konzept der Positionen (Indizes) für den Slice WIRD unten noch einmal dargestellt.

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

Andere Beispiele:

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

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

Negative Werte für Schritt

Wenn umgekehrt Schritt als negativer Wert angegeben WIRD, Werden die Elemente in der Reihenfolge ausgewählt.

Elemente werden ab der Startposition ausgewählt. Beachten Sie, dass es leer ist, es sei denn, start gibt eine Position nach stop an.

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

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

Andere Beispiele:

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

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

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

Indem Sie Start und Stopp weglassen und Schritt auf -1 setzen, erhalten Sie ein umgekehrtes Objekt.

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

Sie können auch reverse() und reversed() verwenden, um Listen oder Strings, Tupel usw. umzukehren. Weitere Informationen finden Sie im folgenden Artikel.

Slice Objekt für Slice()

Sie können ein Slice-Objekt mit der eingebauten Funktion slice() erzeugen. Wenn SIE sterben Elemente wiederholt an derselben Position auswählen möchten, & Sie das Slice-Objekt nur einmal generieren.

Slice(start, stop, step) ist äquivalent zu start:stop:step.

sl = slice(2, 5, 2)
print(sl)
# slice(2, 5, 2)

print(type(sl))
# <class 'slice'>

print(l[sl])
# [20, 40]

Wenn zwei Argumente angegeben werden, wird step auf None gesetzt. Dies entspricht start:stop.

sl = slice(2, 5)
print(sl)
# slice(2, 5, None)

print(l[sl])
# [20, 30, 40]

If nur ein Argument angegeben WIRD, werden start und step auf None gesetzt. Dies ist gleichbedeutend mit: Stopp.

sl = slice(2)
print(sl)
# slice(None, 2, None)

print(l[sl])
# [0, 10]

Wenn alle Argumente ausgelassen Werden, WIRD Ein Fehler TypeError ausgelöst. Wenn SIE : mit Slice() generieren möchten, geben Sie explizit None an.

# sl = slice()
# TypeError: slice expected at least 1 arguments, got 0

sl = slice(None)
print(sl)
# slice(None, None, None)

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

Werte nach Slices zuweisen

Sie können dem durch Slices selected Bereich neue Werte zuweisen.

Es spielt keine Rolle, ob die Anzahl der Elemente in dem durch Slicing ausgewählten Bereich nicht mit der Anzahl der Elemente (= der Länge des Objekts) angezeigt wird, die zugewiesen werden sollen.

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

l[2:5] = [200, 300, 400]
print(l)
# [0, 10, 200, 300, 400, 50, 60]

l[2:5] = [-2, -3]
print(l)
# [0, 10, -2, -3, 50, 60]

l[2:4] = [2000, 3000, 4000, 5000]
print(l)
# [0, 10, 2000, 3000, 4000, 5000, 50, 60]

l[2:6] = [20000]
print(l)
# [0, 10, 20000, 50, 60]

Beachten Sie, dass die Angabe eines Skalarwerts auf der rechten Seite zu TypeError führt.

# l[2:3] = 200
# TypeError: can only assign an iterable

Wenn die rechte Seite leer ist, werden die Elemente in dem durch das Slice ausgewählten Bereich gelöscht.

l[1:4] = []
print(l)
# [0, 60]

Es ist auch möglich, einen Bereich außerhalb des Bereichs oder einen leeren Bereich für die Zuweisung anzugeben. Der Wert auf der rechten Seite wird an der angegebenen Position eingefügt.

l[20:60] = [-1, -2, -3]
print(l)
# [0, 60, -1, -2, -3]

l[2:2] = [-100]
print(l)
# [0, 60, -100, -1, -2, -3]

Wenn die Anzahl der Elemente für den Bereich, in dem Schritt angegeben IST, nicht gleich ist, WIRD ein Fehler ValueError ausgelöst.

print(l[:5:2])
# [0, -100, -2]

l[:5:2] = [100, 200, 300]
print(l)
# [100, 60, 200, -1, 300, -3]

# l[:5:2] = [100, 200]
# ValueError: attempt to assign sequence of size 2 to extended slice of size 3

Um ein Element in der Mitte oder am Ende der Liste hinzuzufügen, stehen Methoden wie insert() und append() zur Verfügung. Siehe folgenden Artikel:

Slices für eine Liste von Listen

Beim Anwenden eines Slice auf eine Liste von Listen (= 2D-Liste) werden innere Listen ausgewählt.

l_2d = [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]

print(l_2d[1:3])
# [[3, 4, 5], [6, 7, 8]]

Um einen Slice auf innere Listen zu verwenden, verwenden Sie List Comprehensions.

print([l[:2] for l in l_2d[1:3]])
# [[3, 4], [6, 7]]

Wenn Sie eine Spalte erhalten möchten, können Sie sie transponieren.

l_2d_t = [list(x) for x in zip(*l_2d)]
print(l_2d_t)
# [[0, 3, 6, 9], [1, 4, 7, 10], [2, 5, 8, 11]]

print(l_2d_t[1])
# [1, 4, 7, 10]

Beachten Sie, dass es einfacher ist, NumPy zum Bearbeiten mehrdimensionaler Arrays zu verwenden, wenn Sie NumPy verwenden können.

In NumPy können Sie für jede Dimension einen Slice als [1:4, 2:5] angeben.

Slices machen eine flache Kopie

Slice erstellt eine flache Kopie. Weitere Informationen zu flachen und tiefen Kopien finden Sie im following Artikel.

Im Falle einer Liste von Zahlen wird beispielsweise das Zuweisen des durch Aufteilen erhaltenen Ergebnisses zu einer Variablen und das Aktualisieren der Elemente der Variablen das ursprüngliche Objekt nicht geändert.

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

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

l_slice[1] = 300
print(l_slice)
# [20, 300, 40]

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

Bei zusammengesetzten Objekten, die Listen, Wörterbücher usw. als Elemente enthalten, ändert das aktualisierte eines Elements das ursprüngliche Objekt.

l_2d = [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]

l_2d_slice = l_2d[1:3]
print(l_2d_slice)
# [[3, 4, 5], [6, 7, 8]]

l_2d_slice[0][1] = 400
print(l_2d_slice)
# [[3, 400, 5], [6, 7, 8]]

print(l_2d)
# [[0, 1, 2], [3, 400, 5], [6, 7, 8], [9, 10, 11]]

Im Beispiel wird die Liste im Slice aktualisiert, und die Liste im ursprünglichen Objekt wird ebenfalls geändert. Wenn die Liste im Originalobjekt aktualisiert WIRD, WIRD auch die Liste im Slice geändert.

Um dies zu verhindern, importieren Sie das Kopiermodul der Standardbibliothek und verwenden Sie deepcopy().

import copy

l_2d = [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]

l_2d_slice_deepcopy = copy.deepcopy(l_2d[1:3])
print(l_2d_slice_deepcopy)
# [[3, 4, 5], [6, 7, 8]]

l_2d_slice_deepcopy[0][1] = 400
print(l_2d_slice_deepcopy)
# [[3, 400, 5], [6, 7, 8]]

print(l_2d)
# [[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]]

Slices für Streicher und Tupel

Bisher haben wir Beispiele für Listen (Listentyp) gezeigt, aber Slices können auch mit anderen Sequenzobjekten wie Strings str und Tuples Tuple used Werden.

Allerdings sind str und tuple unveränderlich, sodass keine neuen Werte zugewiesen werden können.

s = 'abcdefg'

print(s[2:5])
# cde

print(s[::-1])
# gfedcba

# s[2:5] = 'CDE'
# TypeError: 'str' object does not support item assignment

t = (0, 10, 20, 30, 40, 50, 60)

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

# t[2:5] = (200, 300, 400)
# TypeError: 'tuple' object does not support item assignment

Informationen zum Teilen und Ersetzen von Buchstaben finden Sie im following Artikel.