Listen in Python: Welche Implementation wann?

Stell dir vor, du programmierst in deiner Ausbildung oder im Studium eine kleine Aufgabenverwaltung: Neue Aufgaben sollen vorne in die Liste, erledigte fliegen hinten raus. Du nimmst `liste.insert(0, aufgabe)` und wunderst dich, warum das Skript bei 100.000 Einträgen plötzlich Sekunden braucht. Der Grund: Hinter Pythons `list` steckt kein Listen-Typ im Sinne der Informatik, sondern ein dynamisches Array - und das hasst Einfügungen am Anfang. Genau darum geht es hier: Welche Listen-Implementation Python dir anbietet und wann du welche brauchst.

Was steckt hinter Pythons `list`?

Die eingebaute `list` ist ein dynamisches Array: Python reserviert im Speicher zusammenhängenden Platz und vergrößert ihn bei Bedarf automatisch. Stell dir ein Regal vor, das immer länger wird, wenn Bücher nicht mehr passen. Der Zugriff auf ein Element über den Index (`liste[3]`) ist blitzschnell, weil Python die Speicheradresse direkt berechnen kann.

Das hat einen Haken: Willst du vorne etwas einfügen, müssen alle nachfolgenden Elemente einen Platz weiter rücken. Bei einer einfach verketteten Liste (im Informatik-Unterricht oft als `LinkedList` behandelt) wäre das ein einziger Zeiger-Umbau - dafür ist der Zugriff auf Position 3 dort langsam, weil du von vorne durchlaufen musst.

Python bietet keine verkettete Liste als eingebauten Typ, dafür aber Alternativen in der Standardbibliothek. Details dazu findest du in der offiziellen Python-Doku zu Data Structures.

Merke: Pythons `list` ist ein dynamisches Array - schnell beim Indexzugriff und `append`, langsam bei `insert(0, ...)`.

Welche Listen-Implementationen gibt es in Python?

Für listenartige Daten stehen dir vier Kandidaten zur Verfügung: `list`, `tuple`, `deque` und `array.array`. Die Übersicht:

Wann nutzt du `list`?

Die `list` ist deine Standardwahl, wenn du Elemente sammeln, durchlaufen und verändern willst. Sie ist ein dynamisches Array, das am Ende wächst und schrumpft - `append()` und `pop()` sind konstant schnell (O(1)), der Zugriff über den Index ebenfalls. Warum? Weil Python die Position direkt aus dem Index berechnen kann, ohne die Liste zu durchlaufen.

aufgaben = ["Backup pruefen", "Tickets sichten"]
aufgaben.append("Meeting notieren")  # schnell: O(1)
print(aufgaben[0])  # "Backup pruefen", Zugriff O(1)
aufgaben.remove("Meeting notieren")  # langsam: O(n), sucht das Element zuerst

Egal ob Azubi, Student oder Berufseinsteiger: In 90 % der Fällen ist `list` die richtige Antwort. Erreichst du damit eine Grenze (Performance, Unveränderlichkeit), schaust du dir die Alternativen an.

Wann nutzt du `deque`?

Eine `deque` (Double-Ended Queue, sprich: "deck") aus dem `collections`-Modul erlaubt schnelles Anfügen und Entfernen an beiden Enden - jeweils in konstanter Zeit O(1). Intern ist sie als verkettete Liste von Speicherblöcken umgesetzt, nicht als ein großes zusammenhängendes Array. Perfekt also für Stacks (Stapel: LIFO - Last In, First Out) und Queues (Warteschlangen: FIFO - First In, First Out). Details stehen in der Doku zu `collections.deque`.

from collections import deque

warteschlange = deque(["Ticket 1", "Ticket 2"])
warteschlange.append("Ticket 3")  # hinten anstellen
warteschlange.appendleft("VIP")  # vorne einreihen, O(1)!
naechstes = warteschlange.popleft()  # erstes Element entfernen, O(1)
print(naechstes)  # "VIP"

Merke: Brauchst du `insert(0, ...)` oder entfernst du regelmäßig das erste Element, nimm `collections.deque` statt `list`.

Wann nutzt du `tuple`?

Ein `tuple` ist eine unveränderliche Sequenz - einmal erstellt, kannst du den Inhalt nicht mehr ändern. Das klingt nach einer Einschränkung, ist aber ein Feature: Ein Tuple kann als Schlüssel in einem Dictionary dienen, ist als Funktions-Rückgabe mit mehreren Werten ideal und signalisiert jedem Leser "diese Werte gehören zusammen und bleiben fest". Koordinaten, RGB-Farbwerte, (x, y)-Paare - klassische Tuple-Fälle.

koordinate = (52.52, 13.40)  # Breite, Laenge von Berlin
# koordinate[0] = 1.0  # TypeError: 'tuple' object does not support item assignment
farben = {(255, 0, 0): "rot", (0, 255, 0): "gruen"}  # Tuple als Dict-Schluessel

Wann nutzt du `array.array`?

Ein `array` aus dem gleichnamigen Modul speichert viele Werte eines festen Typs (z. B. nur `float` oder nur `int`) kompakt im Speicher - ohne den Overhead der Python-Objekte, den jede Zahl in einer `list` mitbringt. Bei Millionen von Messwerten sparst du damit deutlich RAM. Mehr dazu in der Doku zum `array`-Modul.

import array

messwerte = array.array("d", [1.5, 2.3, 3.9])  # "d" = C-double
messwerte.append(4.2)
# messwerte.append("text")  # TypeError: nur Zahlen erlaubt

Wie schnell ist `deque` im Vergleich zu `list`?

Baue eine FIFO-Warteschlange mit 100.000 Einträgen - einmal falsch mit `list`, einmal richtig mit `deque`. So siehst du den Unterschied selbst:

import timeit
from collections import deque

ANZAHL = 100_000


def mit_liste():
    queue = []
    for i in range(ANZAHL):
        queue.insert(0, i)  # jedes Mal alle Elemente verschieben: O(n)
    while queue:
        queue.pop(0)  # wieder alle verschieben: O(n)
    return queue


def mit_deque():
    queue = deque()
    for i in range(ANZAHL):
        queue.appendleft(i)  # O(1)
    while queue:
        queue.popleft()  # O(1)
    return queue


t_liste = timeit.timeit(mit_liste, number=1)
t_deque = timeit.timeit(mit_deque, number=1)
print(f"list:  {t_liste:.2f} Sekunden")
print(f"deque: {t_deque:.2f} Sekunden")

Messwert: Auf einem normalen Laptop ist die `deque`-Variante um Faktor 100+ schneller. Bei der `list`-Version verschiebt jedes `insert(0, ...)` bis zu 100.000 Elemente - das addiert sich auf mehrere Milliarden Verschiebe-Operationen.

Welche Fehler passieren häufig bei der Wahl der Listen-Implementation?

Fehler 1: `insert(0, ...)` in Schleifen auf einer `list`. Wie im Beispiel oben: Das ergibt O(n²) Laufzeit insgesamt. Richtig ist `deque` mit `appendleft()` und `popleft()`.

Fehler 2: `sort()` und `reverse()` geben `None` zurück. Beide Methoden verändern die Liste direkt (in-place) und liefern nichts zurück. Wer `sortierte_liste = meine_liste.sort()` schreibt, hat danach `None` in der Variablen - ein Klassiker, der gern in Prüfungen auftaucht.

zahlen = [3, 1, 2]
zahlen.sort()  # richtig: aendert die Liste direkt
sortiert = sorted(zahlen)  # richtig: gibt eine neue Liste zurueck
falsch = zahlen.sort()  # falsch: hier steht None drin!

Fehler 3: Tuple als "komplett unveränderlich" missverstanden. Ein Tuple verhindert nur das Neuzuweisen seiner direkten Einträge. Enthält es eine `list`, bleibt die veränderbar:

paar = (1, [2, 3])
paar[1].append(4)  # klappt! Die innere Liste ist veraenderbar
# paar[0] = 9       # TypeError: Tuple-Eintrag selbst nicht austauschbar

Das gilt übrigens für alle "unveränderlichen" Container - die Unveränderlichkeit ist nie tiefgehend (deep).

Wie übst du das am besten?

Nimm das Praxisbeispiel und variiere es: Schreibe einen kleinen Browser-Verlauf mit Vor- und Zurück-Button. Tipp: Zwei Stacks (`deque`) eignen sich dafür perfekt - beim Klicken auf "zurück" popst du vom aktuellen Stack und pusht auf den Verlaufs-Stack. Wenn du das in 20 Zeilen hinbekommst, hast du das Konzept hinter Stack und Queue verinnerlicht - ein Thema, das in der IHK-Abschlussprüfung von Fachinformatikern gern abgefragt wird. Wie Python generell durch Sequenzen iteriert, habe ich übrigens im Artikel zu Iterable und Iterator in Python aufgeschrieben.

FAQ: Häufige Fragen zu Python Listen Implementation

Hat Python eine verkettete Liste?

Nein, keinen eingebauten Typ. Die `list` ist ein dynamisches Array. Für verkettete-Listen-Verhalten (schnelles Einfügen/Entfernen an beiden Enden) nutzt du `collections.deque`.

Was ist schneller: `list` oder `deque`?

Kommt auf die Operation an: Indexzugriff (`daten[500]`) und `append` gewinnt die `list`. Einfügen/Entfernen am Anfang gewinnt `deque` klar, weil dort konstante Zeit gilt.

Wann `list`, wann `tuple`?

`list`, wenn sich die Daten ändern sollen oder dynamisch wachsen. `tuple`, wenn die Werte fest zusammengehören - als Dict-Schlüssel oder festes Wertepaar wie Koordinaten.

Warum ist `liste.insert(0, x)` so langsam?

Weil alle vorhandenen Elemente im Array eine Position nach hinten verschoben werden müssen. Das kostet O(n) pro Aufruf, in einer Schleife also O(n²) insgesamt.

Soll ich für Zahlen `array.array` statt `list` nehmen?

Nur bei sehr großen, typgleichen Datenmengen (ab mehreren hunderttausend Werten) lohnt sich der geringere Speicherverbrauch. Für alltäglichen Code ist `list` klarer und flexibler. Für echte Numerik greift man eher zu NumPy.

Fazit

Für die Python-Listen-Implementation gilt eine einfache Regel: `list` ist dein Standard, `deque` kommt bei Stack und Queue ins Spiel, `tuple` wenn Daten fest sind, und `array.array` bei riesigen Zahlenmengen. Wer diese vier Typen unterscheiden kann, löst nicht nur Prüfungsaufgaben schneller, sondern schreibt auch im Berufsalltag Code, der bei großen Datenmengen flüssig läuft.

Wenn du bei Python, Datenstrukturen oder anderen IT-Themen individuell Unterstützung brauchst - ob für die nächste IHK-Prüfung, das Studium oder den Berufseinstieg: Die Nachhilfe von study-it.education passt sich genau deinem Niveau an. Schau vorbei und lerne mit Leuten, die selbst durch die gleichen Themen durchgegangen sind.