Python Listen erweitern - append, extend, insert? Die Wahl ist einfach!

Beim Erweitern von Listen in Python geht es meist um ganz praktische Entscheidungen: Hänge ich einen einzelnen Wert an, übernehme ich mehrere Elemente auf einmal oder füge ich Daten an einer festen Position ein? Wer hier die falsche Methode wählt, produziert schnell verschachtelte Listen, unnötige Kopien oder Seiteneffekte, die später teuer werden. Ich zeige dir deshalb die wichtigsten Varianten, typische Fehler und eine klare Faustregel für sauberen, gut lesbaren Code.

Wann du Listen in Python gezielt erweiterst

In echten Projekten passiert das ständig: Eine API liefert neue Datensätze, ein Deployment-Skript ergänzt zusätzliche Hosts, oder ein Parser sammelt Konfigurationswerte aus mehreren Quellen. Genau dann willst du meist keine neue Datenstruktur erfinden, sondern eine bestehende Liste kontrolliert erweitern. Ich trenne dabei zuerst immer zwischen zwei Fragen: Kommt genau ein Element dazu? Oder kommen mehrere Werte aus einem Iterable?

Diese Unterscheidung ist wichtiger, als sie auf den ersten Blick wirkt. Wenn du ein einzelnes Objekt anhängen willst, ist `append()` klarer. Wenn du mehrere Elemente übernehmen möchtest, ist `extend()` oder `+=` die bessere Wahl. Und wenn die Originaldaten unangetastet bleiben sollen, ist eine neue Liste oft die sauberere Lösung. Genau an dieser Stelle entscheidet sich, ob dein Code später leicht lesbar bleibt oder bei der ersten Änderung unnötig kompliziert wird.

Als Nächstes lohnt sich der direkte Vergleich der Methoden, denn viele Verwechslungen entstehen nicht bei der Idee, sondern bei der konkreten Wirkung.

append, extend und += im direkten Vergleich

Die drei häufigsten Varianten sehen ähnlich aus, lösen aber unterschiedliche Probleme. Der Unterschied ist klein im Code, aber groß im Ergebnis.

Das klassische Missverständnis sieht so aus: Mit append() bekommt die Liste einen neuen Eintrag, selbst wenn dieser Eintrag wiederum eine Liste ist. Mit extend() wird die innere Liste dagegen aufgelöst. Genau das macht den Unterschied zwischen einer flachen Liste und einer verschachtelten Struktur aus.

werte = [1, 2]

werte.append([3, 4])
print(werte)          # [1, 2, [3, 4]]

werte = [1, 2]
werte.extend([3, 4])
print(werte)          # [1, 2, 3, 4]

werte = [1, 2]
werte += [3, 4]
print(werte)          # [1, 2, 3, 4]

Ich nutze in Projekten deshalb meist diese einfache Regel: Ein Objekt, ein Anhang mit `append()`; mehrere Werte, `extend()` oder `+=`. Wenn ich die alte Liste unbedingt unverändert lassen muss, wähle ich die neue Liste per + oder baue bewusst eine Kopie. Damit ist die Grundentscheidung schon getroffen, und der Rest wird schnell zur Frage der Datenquelle.

So kombinierst du Listen, Iterables und Generatoren sauber

extend() ist flexibler, als viele erwarten. Es nimmt nicht nur Listen an, sondern jedes Iterable. Das macht die Methode in Skripten besonders nützlich, wenn Daten aus verschiedenen Quellen kommen: aus range(), aus einem Generator, aus einem Tuple oder aus einem Iterator, der Zeile für Zeile liefert. Für Import- und Automatisierungsskripte ist das oft genau die richtige Form.

Wichtig ist dabei eine kleine, aber praktische Feinheit: Ein Generator wird beim Erweitern einmal konsumiert. Danach ist er leer. Das ist kein Fehler, sondern normales Verhalten. Wenn du denselben Datenstrom mehrfach brauchst, musst du ihn vorher materialisieren, etwa über list(). Für große Datenmengen ist das allerdings nicht immer sinnvoll, weil du dann Speicher belegst, den du eigentlich gar nicht brauchst.

basis = [10]
basis.extend(range(11, 14))
print(basis)          # [10, 11, 12, 13]

namen = ["alice"]
namen.extend(name for name in ("bob", "carla"))
print(namen)          # ['alice', 'bob', 'carla']

Ein Detail, das ich in Reviews immer wieder anspreche: Wenn du ein Dict an extend() übergibst, landen die Schlüssel in der Liste, nicht die Werte. Das ist logisch, weil ein Dictionary über seine Schlüssel iteriert. Wenn du also Werte, Paare oder Einträge einer Konfiguration übernehmen willst, musst du das explizit machen.

daten = []
daten.extend({"host": "db01", "port": 5432})
print(daten)          # ['host', 'port']

Wenn ich eine Liste an einer festen Stelle ergänzen will, schreibe ich manchmal auch eine Slice-Zuweisung. Technisch ist das eng mit extend() verwandt und im Code sehr klar lesbar, wenn der Einfügepunkt wichtig ist. Danach lohnt sich der Blick auf die Fehler, die in der Praxis am häufigsten Zeit kosten.

Typische Fehler, die ich immer wieder sehe

Der häufigste Fehler ist fast banal: Jemand erwartet, dass append() oder extend() einen neuen Wert zurückgeben. Tun sie nicht. Beide Methoden verändern die Liste direkt und liefern bewusst None. Wer den Rückgabewert speichert, überschreibt seine Variable mit nichts Nutzbarem.

werte = [1, 2]
werte = werte.append(3)
print(werte)          # None

Der zweite Klassiker ist der falsche Einsatz von append() bei mehreren Werten. Das erzeugt eine verschachtelte Struktur, die später bei Schleifen, Serialisierung oder JSON-Verarbeitung unnötig stört. Ich sehe das besonders oft bei Daten, die aus APIs oder CSV-Dateien kommen, weil man intuitiv denkt: „Ich hänge noch schnell die neuen Werte an.“ In Wirklichkeit braucht man aber oft extend().

werte = [1, 2]
neue_werte = [3, 4]

werte.append(neue_werte)
# [1, 2, [3, 4]]  -- meist nicht gewollt

werte = [1, 2]
werte.extend(neue_werte)
# [1, 2, 3, 4]

Ein dritter Stolperstein betrifft die Lesbarkeit und die Kosten. Wenn du in einer Schleife immer wieder liste = liste + [x] schreibst, erzeugst du bei jedem Durchlauf eine neue Liste. Für kleine Datenmengen ist das harmlos, bei vielen Elementen kann das aber schnell unnötig teuer werden, weil jedes Mal kopiert wird. Für große Datenströme ist das oft der Unterschied zwischen sauberem und träge gewordenem Code.

Und dann ist da noch das Thema Aliasierung: Wenn zwei Variablen auf dieselbe Liste zeigen, verändert eine In-Place-Operation beide Sichtweisen gleichzeitig. Genau deshalb prüfe ich in größeren Skripten immer, ob eine Mutation wirklich erwünscht ist. Dieser Punkt führt direkt zur Frage, wann ich überhaupt eine andere Schreibweise oder sogar eine andere Datenstruktur wähle.

Wann ich lieber eine andere Schreibweise oder Struktur nehme

Für reine Anhänge am Ende ist eine Liste stark genug. Sobald aber die Zugriffslogik wächst, lohnt sich ein genauerer Blick. Wenn du häufig am Anfang einfügst, mitten in der Liste arbeitest oder viele Elemente verschiebst, wird eine Liste schnell unpraktisch. Das liegt nicht an Python, sondern an der internen Struktur: Listen sind auf schnelles Zugreifen und Anhängen optimiert, nicht auf ständiges Verschieben großer Datenmengen.

Ich verwende deshalb in solchen Fällen klare Faustregeln:

• Wenn genau ein Objekt dazukommt, nehme ich append().
• Wenn mehrere Werte dazukommen, nehme ich extend().
• Wenn das Original unverändert bleiben soll, bilde ich eine neue Liste mit + oder einer Kopie.
• Wenn ich an einer festen Position einfüge, nutze ich insert() oder Slice-Zuweisung.
• Wenn es eher wie eine Warteschlange funktioniert, schaue ich mir lieber collections.deque an.

Der letzte Punkt ist besonders in Infrastruktur- und Automatisierungsskripten relevant, etwa bei Jobwarteschlangen, Ereignislisten oder verarbeiteten Logeinträgen. Eine deque ist für Einfügen und Entfernen an beiden Enden oft die bessere Wahl als eine Liste, weil du damit die verschiebungsintensiven Operationen vermeidest. Für einfache Sammelstrukturen bleibe ich aber bei der Liste, weil sie klarer und meist völlig ausreichend ist.

Auch Slice-Zuweisung ist eine gute Option, wenn ich bewusst ausdrücken will, dass etwas an eine vorhandene Liste angehängt wird. Technisch ist das kein magischer Sonderweg, sondern nur eine sehr direkte Schreibweise für denselben Effekt. Der Vorteil ist die Lesbarkeit im Kontext: Man sieht sofort, dass bestehende Daten erweitert werden und nichts neu aufgebaut wird.

Damit ist die eigentliche Entscheidung oft schon entschieden: nicht nach der kürzesten Schreibweise suchen, sondern nach der Methode, die das Datenmodell ehrlich beschreibt.

Die pragmatische Regel, die ich in Projekten beibehalte

Wenn ich Listen in Python erweitere, gehe ich fast immer nach derselben Reihenfolge vor: Erst frage ich, ob ein einzelner Wert oder mehrere Werte hinzukommen. Dann prüfe ich, ob die bestehende Liste verändert werden darf. Erst danach entscheide ich zwischen append(), extend(), += oder einer neuen Liste. Diese Reihenfolge ist schlicht, aber sie verhindert die meisten Fehler schon vor dem Schreiben der ersten Zeile.

Für produktiven Code halte ich außerdem drei Dinge im Blick: Mutationen sollen bewusst sein, Rückgabewerte mutierender Methoden werden nicht weiterverwendet, und große Datenmengen sollten nicht unnötig kopiert werden. Wer diese Punkte beachtet, schreibt robuste Listenlogik, die auch nach Monaten noch verständlich bleibt.

Die technische Kurzform lautet für mich: Ein Element anhängen, mehrere Elemente erweitern, Originaldaten nur dann verändern, wenn das fachlich wirklich passt. Genau diese Haltung spart später Debugging-Zeit, weil die Liste das tut, was der Code eindeutig sagt.