Listen in Python (list): Methoden, Slices, Sortierung, append, Tupel und Mengen

Eine Liste (list) in Python ist eine geordnete Sammlung beliebiger Werte in eckigen Klammern, die sich verändern lässt: Sie können Elemente am Ende anhängen, in die Mitte einfügen, entfernen und sortieren. Es ist die meistgenutzte Sammlung der Sprache. Zeilen einer Datei, Ausgaben eines Monats, Antworten einer API: fast alles beginnt mit einer Liste. Wir gehen die Liste in Python vollständig durch: Anlegen, Methoden, Slices, Sortierung, Comprehensions, Kopieren, und zum Schluss Tupel und Mengen.

Was eine Liste in Python ist

Eine Liste speichert Elemente in der Reihenfolge, in der Sie sie angelegt haben, und Sie greifen über einen Index ab 0 darauf zu. In einer Liste dürfen Werte verschiedener Typen liegen, in der Praxis speichert man aber meist gleichartige Daten.

amounts = [250, 1200, 99]
print(amounts[0])     # 250 — erstes Element
print(amounts[-1])    # 99 — letztes
amounts[1] = 1300     # die Liste ist veränderbar
print(len(amounts))   # 3 — Länge der Liste

Die Größe einer Liste liefert die Funktion len(). Ein Zugriff auf einen nicht vorhandenen Index ergibt IndexError: list index out of range.

Eine Liste anlegen

empty = []                       # leere Liste
also_empty = list()              # dasselbe über die Funktion list
nums = [1, 2, 3]
chars = list("abc")              # ['a', 'b', 'c']
digits = list(range(5))          # [0, 1, 2, 3, 4]
zeros = [0] * 4                  # [0, 0, 0, 0]

Die Funktion list() wandelt jedes iterierbare Objekt in eine Liste um: eine Zeichenkette, einen range, eine Menge oder die Schlüssel eines Dictionaries.

append und andere Methoden von Listen

Die Methode append hängt ein einzelnes Element an das Ende der Liste an. Sie ist die häufigste Methode in Python. Sie verändert die Liste direkt und liefert None.

amounts = [250, 1200]
amounts.append(450)          # [250, 1200, 450]
amounts.extend([10, 20])     # [250, 1200, 450, 10, 20]
amounts.insert(0, 5)         # [5, 250, 1200, 450, 10, 20]
amounts.remove(1200)         # erster Wert 1200 wird entfernt
last = amounts.pop()         # 20 — entfernt und zurückgegeben wird das letzte

Ein häufiger Fehler: a.append([10, 20]) hängt ein einziges Element an, nämlich eine verschachtelte Liste, und nicht zwei Zahlen. Für mehrere Elemente brauchen Sie extend.

Ein Element an einem Index oder einen ganzen Bereich entfernen Sie auch mit dem Operator del: del a[0], del a[1:3]. Nützliche eingebaute Funktionen für Listen sind len, sum, min, max, sorted, reversed, enumerate und zip.

Slices in Python

Ein Slice holt einen Teil der Liste nach dem Schema a[start:stop:step]: von start einschließlich bis stop ausschließlich, mit der Schrittweite step. Jeder Teil darf weggelassen werden. Ein Slice liefert immer eine neue Liste.

a = [0, 1, 2, 3, 4, 5]
print(a[1:4])     # [1, 2, 3]
print(a[:2])      # [0, 1] — die ersten beiden
print(a[-2:])     # [4, 5] — die letzten beiden
print(a[::2])     # [0, 2, 4] — jedes zweite
print(a[::-1])    # [5, 4, 3, 2, 1, 0] — umgekehrt
print(a[:])       # Kopie der ganzen Liste

Anders als ein Index löst ein Slice außerhalb der Liste keinen Fehler aus: a[10:20] liefert einfach []. Einem Slice können Sie auch einen Wert zuweisen und damit einen Teil der Liste ersetzen: a[1:3] = ["x", "y", "z"].

Slice einer Zeichenkette

Slices funktionieren genauso bei allen Folgen, also auch bei Strings und Tupeln:

s = "Python 3.15"
print(s[:6])      # Python
print(s[-4:])     # 3.15
print(s[::-1])    # 51.3 nohtyP

Einen String können Sie per Slice nicht verändern. Strings sind unveränderlich, ein Slice erzeugt einen neuen String.

Liste sortieren: sort und sorted

Hier verwechseln Einsteiger am häufigsten etwas. Die Methode sort ordnet die Elemente in der Liste selbst und liefert None. Die Funktion sorted lässt die ursprüngliche Liste unangetastet und liefert eine neue sortierte Liste.

amounts = [250, 1200, 99]
amounts.append(450)
print(sorted(amounts))     # [99, 250, 450, 1200] — neue Kopie
print(amounts)             # [250, 1200, 99, 450] — das Original bleibt

result = amounts.sort()    # sortiert direkt
print(result, amounts)     # None [99, 250, 450, 1200]

Daher kommt der klassische Fehler „Warum ist das None?“: a = a.sort() überschreibt die Liste mit dem Wert None. Schreiben Sie entweder a.sort() oder a = sorted(a).

Schlüssel und absteigende Reihenfolge

Beide Varianten akzeptieren die Parameter key und reverse. key ist eine Funktion, deren Ergebnis zum Vergleichen der Elemente dient.

words = ["Kaffee", "Taxi", "Abonnement"]
print(sorted(words, key=len))               # ['Taxi', 'Kaffee', 'Abonnement'] — nach Länge
print(sorted(words, key=str.lower))         # ohne Beachtung der Groß- und Kleinschreibung
print(sorted([3, 1, 2], reverse=True))      # [3, 2, 1]

expenses = [("Essen", 650), ("Kino", 120), ("Taxi", 300)]
expenses.sort(key=lambda e: e[1])           # nach Betrag

Die Sortierung in Python ist stabil: Elemente mit gleichem Schlüssel behalten ihre ursprüngliche Reihenfolge. Ein Unterschied besteht außerdem beim Anwendungsbereich: sorted akzeptiert jede Folge (Zeichenkette, Dictionary, Menge), sort gibt es nur für Listen.

Liste umkehren

Es gibt drei Möglichkeiten mit unterschiedlichem Verhalten:

• a.reverse() — kehrt direkt um und liefert None;
• a[::-1] — eine neue, umgekehrte Liste;
• reversed(a) — ein fauler Iterator, praktisch in Schleifen: for x in reversed(a):.

Eine Liste durchlaufen

items = ["Kaffee", "U-Bahn", "Kino"]
for item in items:
    print(item)

for i, item in enumerate(items, start=1):
    print(i, item)          # 1 Kaffee, 2 U-Bahn, 3 Kino

print("Kino" in items)      # True — Prüfung auf Enthaltensein

Entfernen Sie keine Elemente aus der Liste, über die gerade eine Schleife läuft, sonst werden einige übersprungen. Bauen Sie stattdessen eine neue Liste mit einer Comprehension oder durchlaufen Sie eine Kopie a[:].

Listen-Comprehension

Eine Listen-Comprehension erzeugt eine neue Liste in einer einzigen Zeile: einen Ausdruck, eine Schleife und optional eine Bedingung.

squares = [n * n for n in range(6)]          # [0, 1, 4, 9, 16, 25]
big = [a for a in [250, 1200, 99] if a > 200]  # [250, 1200]
names = [s.strip().title() for s in [" anna ", "olaf"]]  # ['Anna', 'Olaf']

Comprehensions sind meist schneller und besser lesbar als eine Schleife mit append. Passt die Logik aber nicht in eine übersichtliche Zeile, ist eine normale Schleife die bessere Wahl.

Listen verbinden, addieren und subtrahieren

a = [1, 2, 3]
b = [3, 4]
print(a + b)       # [1, 2, 3, 3, 4] — neue Liste
a += b             # wie a.extend(b)
print([*a, *b])    # Entpacken in eine neue Liste

Für das Subtrahieren von Listen mit dem Operator - gibt es keine Entsprechung. Um Elemente einer Liste aus einer anderen zu entfernen, verwenden Sie eine Comprehension: [x for x in a if x not in set(b)]. Die Schnittmenge zweier Listen finden Sie am bequemsten mit Mengen: set(a) & set(b) (dabei gehen Reihenfolge und Dubletten verloren).

Verschachtelte und zweidimensionale Listen

Eine Liste aus Listen ist eine einfache Möglichkeit, eine Tabelle oder Matrix zu speichern:

matrix = [[1, 2, 3], [4, 5, 6]]
print(matrix[1][2])     # 6
grid = [[0] * 3 for _ in range(2)]   # richtig
bad = [[0] * 3] * 2                  # Falle: zwei Verweise auf dieselbe Liste
bad[0][0] = 9
print(bad)              # [[9, 0, 0], [9, 0, 0]]

Liste entpacken

first, second, third = [10, 20, 30]
head, *rest = [1, 2, 3, 4]      # head=1, rest=[2, 3, 4]
print(*["a", "b"], sep=", ")    # a, b — print einer Liste ohne Klammern

Stimmt die Anzahl der Variablen nicht mit der Länge der Liste überein, gibt es einen ValueError. Hier hilft der Stern weiter.

Liste kopieren

b = a kopiert die Liste nicht, sondern hängt ein zweites Etikett an dasselbe Objekt: Änderungen über b sind in a sichtbar. Eine unabhängige Kopie erstellen Sie ausdrücklich: a.copy(), list(a) oder a[:]. Bei verschachtelten Daten reicht das nicht, die inneren Listen bleiben gemeinsam. Dann brauchen Sie copy.deepcopy(a).

import copy
a = [[1, 2], [3]]
b = a.copy()
b[0].append(99)
print(a)                 # [[1, 2, 99], [3]] — die verschachtelte Liste ist gemeinsam
c = copy.deepcopy(a)     # vollständig unabhängige Kopie

Tupel: eine unveränderliche Liste

Ein Tupel (tuple) ähnelt einer Liste, lässt sich aber nach dem Anlegen nicht mehr ändern. Das ist ein klares Signal an den Leser: Hier steht ein Datensatz mit festen Feldern, keine wachsende Sammlung. Tupel lassen sich bequem entpacken, und Funktionen geben damit oft mehrere Werte zurück.

expense = (250, "Kaffee")
amount, item = expense
expense[0] = 300
# TypeError: 'tuple' object does not support item assignment

Ein Tupel aus unveränderlichen Werten ist hashbar und kann deshalb als Schlüssel eines Dictionaries dienen. Ein Tupel mit nur einem Element schreibt man mit Komma: (5,).

Mengen: nur Eindeutiges

Eine Menge (set) speichert nur eindeutige Werte und merkt sich keine Reihenfolge. Das ist der schnellste Weg, Dubletten zu entfernen und zu prüfen, ob ein Element vorhanden ist. Außerdem beherrscht sie Schnittmenge, Vereinigung und Differenz.

jan = {"Essen", "Taxi", "Kino"}
feb = {"Essen", "Abos"}
print(jan & feb)    # {'Essen'}
print(feb - jan)    # {'Abos'}
unique = list(dict.fromkeys([3, 1, 3, 2]))   # [3, 1, 2] — ohne Dubletten, Reihenfolge bleibt
empty = set()       # {} wäre ein leeres dict!

Welche Sammlung Sie wählen sollten

Die Prüfung x in list durchläuft die Elemente nacheinander, x in set arbeitet nahezu sofort. Wenn Sie in einer Schleife oft prüfen, ob ein Wert in einer großen Liste vorkommt, wandeln Sie die Liste in eine Menge um.

Fazit

Die Liste in Python ist eine geordnete, veränderbare Sammlung: append und extend fügen hinzu, pop und remove entfernen, Slices a[start:stop:step] holen Teile heraus, sort sortiert direkt und liefert None, sorted gibt eine neue Liste zurück. Kopieren Sie bewusst, für feste Datensätze nehmen Sie ein Tupel, für eindeutige Werte eine Menge. Listen, Tupel, Dictionaries und Mengen werden im Kurs „Python 3.15: vom Einsteiger zum Profi“ praktisch durchgespielt.