# Zu Python-Liste hinzufügen Listen sind grundlegende Datenstrukturen in der Informatik. Viele **Algorithmen beruhen darauf, Listen zu modifizieren**. Wir zeigen, wie sich in Python Elemente zu einer Liste hinzuzufügen lassen. ## Wie lassen sich Elemente zu einer Python-Liste hinzufügen? Anders als Tupel und Strings sind **Listen in Python „mutable“, d. h. veränderbare Datenstrukturen**. Wir können Elemente zu einer [Python-Liste](https://www.ionos.de/digitalguide/websites/web-entwicklung/python-list/ "Python-List") hinzufügen, Elemente entfernen und die Reihenfolge der Elemente ändern. Dazu gibt es verschiedene Ansätze, die jeweils eigene Vor- und Nachteile haben. Wir **stellen die folgenden vier Ansätze vor**, mit denen Sie in Python einer Liste Elemente hinzufügen können: 1. Mit den Python-`list`-Methoden Elemente zu einer Liste hinzufügen 2. Mit Listen-Konkatenation in Python Elemente zu einer Liste hinzufügen 3. Mit Slice-Notation Elemente in Python zu einer Liste hinzufügen 4. Mit List Comprehension Python-Elemente zu einer Liste hinzufügen ## Mit den Python-list-Methoden Elemente zu einer Liste hinzufügen In Python dient die **Klasse `list` als Grundlage für sämtliche Listen-Operationen**. Die Klasse definiert eine Reihe von Methoden für Listen-Objekte. Dazu gehören drei Methoden, die sich zum Hinzufügen von Elementen zu einer Liste eignen:
`list`-Methode Argumente Erklärung
`append()` `element` In einzelnes Element zum Ende der Liste hinzufügen
`extend()` `[elements]` Mehrere Elemente zum Ende der Liste hinzufügen
`insert()` `index, element` Ein einzelnes Element vor dem gegebenen Index hinzufügen
Wichtig zu verstehen ist, dass die **Veränderung bei den drei genannten Methoden „in-place“ erfolgt**. Das bedeutet, dass das Listen-Objekt verändert wird, anstatt eine neue Liste zu erzeugen und zurückzugeben. Konsequenterweise geben die Methoden allesamt `None` zurück: ```Python # List of prime numbers primes = [2, 3, 5, 7] # Append additional prime number, saving returned result should_be_none = primes.append(11) # Show that the prime was added assert primes == [2, 3, 5, 7, 11] # Show that `None` was returned assert should_be_none is None ``` ### Mit append() ein einzelnes Element zum Ende der Liste hinzufügen Mit der [Python-`append()`-Methode](https://www.ionos.de/digitalguide/websites/web-entwicklung/python-append/) lässt sich ein **einzelnes Element zum Ende einer bestehenden Liste hinzufügen**. Veranschaulichen wir uns das Verhalten an einem Beispiel: ```Python # List containing single prime number primes = [2] # Add an element to the end of the list primes.append(3) # Show that the element was added assert primes == [2, 3] ``` Vorsicht bei der Nutzung von `append()` – die Methode **fügt immer ein einzelnes Element hinzu**. Handelt es sich beim hinzuzufügenden Element um eine weitere Liste, entsteht eine verschachtelte Liste: ```Python # List with two prime numbers primes = [2, 3] # Try to appends multiple numbers at once primes.append([5, 7]) # Accidentally created a nested list assert primes == [2, 3, [5, 7]] ``` Unser Versuch, die Liste `[2, 3, 5, 7]` zu erzeugen, ist fehlgeschlagen. Um mehrere Elemente hinzuzufügen, nutzen wir besser die `extend()`-Methode. ### Mit extend() Elemente zum Ende der Liste hinzufügen Die [Python-`extend()`-Methode](https://www.ionos.de/digitalguide/websites/web-entwicklung/python-extend/) funktioniert ähnlich wie `append()`, mit dem Unterschied, dass **einer bestehenden Liste mehrere Elemente hinzugefügt werden**. Betrachten wir zum Verständnis wiederum ein Beispiel: ```Python # List containing single prime number primes = [2] # Extend list by two elements primes.extend([3, 5]) # Show that both element were added assert primes == [2, 3, 5] ``` Vorsicht bei `extend()` – die Methode erwartet ein **Iterable als Argument und entpackt dessen Elemente**. Dies führt beim Aufruf mit einem String zu überraschendem Verhalten: ```Python # List of friends friends = ['Mary', 'Jim'] # Try to extend by additional friend friends.extend('Jack') # String is unpacked into individual letters assert friends == ['Mary', 'Jim', 'J', 'a', 'c', 'k'] ``` Um ein einzelnes Element zu einer Python-Liste hinzuzufügen, nutzt man entweder `append()` oder **schließt das Element mit eckigen Klammern in eine Liste ein**. Dann funktioniert auch der Aufruf von `extend()`: ```Python # List of friends friends = ['Mary', 'Jim'] # Extend by additional friend inside list friends.extend(['Jack']) # Show that it worked assert friends == ['Mary', 'Jim', 'Jack'] ``` ### Mit insert() ein einzelnes Element vor dem angegebenen Index hinzufügen Bisher haben wir gezeigt, wie sich ein oder mehrere Elemente zum Ende einer Python-Liste hinzufügen lassen. Was jedoch, wenn wir **ein Element an einer beliebigen Position einfügen** möchten? Genau für diesen Fall gibt es die [Python-`insert()`-Methode](https://www.ionos.de/digitalguide/websites/web-entwicklung/python-insert/). Diese nimmt zusätzlich zum einzufügenden Element einen numerischen Index entgegen: ```Python # List of friends friends = ['Mary', 'Jim', 'Jack'] # Insert additional friend `"Molly"` before index `2` friends.insert(2, 'Molly') # Show that "Molly" was added assert friends == ['Mary', 'Jim', 'Molly', 'Jack'] ``` Vorsicht beim Versuch, mehrere Elemente mit `insert()` hinzuzufügen – da `insert()` genau ein Element einfügt, **erzeugen wir ungewollt eine verschachtelte Liste**: ```Python # List of friends friends = ['Mary', 'Jim'] # Try to insert multiple friends at once friends.insert(1, ['Molly', 'Lucy']) # Accidentally created a nested list assert friends == ['Mary', ['Molly', 'Lucy'], 'Jim'] ``` Um **mehrere Elemente korrekt innerhalb einer Liste einzufügen**, nutzen wir eine `for`-Schleife. Ferner bedienen wir uns der `reversed()`-Funktion, um die Reihenfolge der eingefügten Elemente beizubehalten: ```Python # List of friends friends = ['Mary', 'Jim'] # Using `reversed()` keeps order of inserted elements for friend in reversed(['Molly', 'Lucy']): friends.insert(1, friend) # Show that it worked assert friends == ['Mary', 'Molly', 'Lucy', 'Jim'] ``` ## Mit Listen-Konkatenation in Python Elemente zu einer Liste hinzufügen Neben den vorgestellten `list`-Methoden existiert mit der **Listen-Konkatenation eine weitere Möglichkeit, einer Python-Liste Elemente hinzuzufügen**. Dabei kommt der Python `+`-Operator zum Einsatz. Die Listen-Konkatenation entspricht in etwa der Nutzung von `extend()`. Jedoch erzeugt die Konkatenation eine neue Liste, anstatt „in-place“ zu operieren. Wir erzeugen zwei Listen und fügen die zweite der ersten hinzu. Da die **Operation eine neue Liste zurückgibt**, weisen wir den Rückgabewert einer neuen Liste zu: ```Python # List of guys guys = ['Jim', 'Jack'] # List of gals gals = ['Molly', 'Mary'] # Concatenate both lists folks = guys + gals # Show that it worked assert folks == ['Jim', 'Jack', 'Molly', 'Mary'] ``` Unter der Haube **ruft der Konkatenations-Operator die `__add__()`-Methode auf**. Die Ausdrücke `guys + gals` und `guys.__add__(gals)` sind also äquivalent: ```Python # Show that both expressions return the same result assert guys + gals == guys.__add__(gals) ``` Falls Sie sich mit den [Python-Operatoren](https://www.ionos.de/digitalguide/websites/web-entwicklung/python-operatoren/ "Python-Operatoren") auskennen, ahnen Sie es vielleicht bereits. Die **Listen-Konkatenation unterstützt auch das Augmented Assignment**. Dabei kommt der `+=`-Operator zum Einsatz, um Elemente zu einer Liste „in-place“ hinzuzufügen: ```Python # Shopping list groceries = ['Milk', 'Bread', 'Eggs'] # Add butter groceries += ['Butter'] # Show that it worked assert groceries == ['Milk', 'Bread', 'Eggs', 'Butter'] ``` Der `+=`-Operator ruft die `__iadd__()`-Methode auf, wobei das „i“ für „in-place“ steht. Analog zur `extend()`-Methode wird der **Empfänger der Methode direkt modifiziert**. Die folgenden Zeilen sind also äquivalent: - `groceries = groceries + ['Butter']` - `groceries += ['Butter']` - `groceries.__iadd__(['Butter'])` - `groceries.extend(['Butter'])` Vorsicht gilt, wenn die Listen-Konkatenations-Operatoren zum Einsatz kommen, um einer Liste ein einzelnes Element hinzuzufügen. Auch ein **einzelnes Element muss in einer Liste enthalten sein**, ansonsten wird ggf. ein Iterable entpackt: ```Python # List of cities cities = ['London', 'Paris'] # Attempt to add city; likely not what you intended cities += 'Rome' # String is unpacked into individual letters assert cities = ['London', 'Paris', 'R', 'o', 'm', 'e'] ``` Die **Nutzung einer einelementigen Liste führt zum wahrscheinlich gewünschten Effekt**, der Liste eine weitere Stadt hinzuzufügen: ```Python # List of cities cities = ['London', 'Paris'] # Create a single-element list cities += ['Rome'] # Now the entire string is added assert cities = ['London', 'Paris', 'Rome'] ``` ## Mit Slice-Notation Elemente in Python zu einer Liste hinzufügen Slices sind ein **Python-Feature zum Auswählen aufeinanderfolgender Elemente einer Liste**. Die Syntax von Slices entspricht der bekannten `range()`-Funktion: ```Python # The `slice()` function constructs a new `slice` object slice(start, stop, step=1) ``` Ferner gibt es eine **„Shorthand“-Notation zum Erzeugen von Slice-Objekten** in Verbindung mit dem Index-Operator `[]`: ```Python # Select items of list lst[start:stop:step] ``` Ein **Slice-Objekt lässt sich anstelle eines numerischen Index verwenden**, um mehrere Elemente einer Sequenz auszuwählen: ```Python people = ['Jim', 'John', 'Mary', 'Jack'] # Select elements between index `1` (inclusive) and `3` (exclusive) assert people[1:3] == ['John', 'Mary'] # Select every other element assert people[::2] == ['Jim', 'Mary'] ``` In **Kombination mit Zuweisungen** lassen sich Slices als Alternative für die `list`-Methoden `append()`, `extend()` und `insert()` verwenden:
`list`-Methode Korrespondierende Slice-Zuweisung Erklärung
`lst.append(element)` `lst[len(lst)+1:] = [element]` Ein Element zum Ende der Liste hinzufügen
`lst.extend([elements])` `lst[len(lst)+1:] = [elements]` Mehrere Elemente zum Ende der Liste hinzufügen
`lst.insert(index, element)` `lst[index:index] = [element]` Ein Element vor dem gegebenen Index hinzufügen
Um zu verstehen, wie das funktioniert, betrachten wir zunächst die **Zuweisung eines Listen-Elements per numerischem Index**. Dabei wird ein einzelnes Listen-Element überschrieben: ```Python # List of groceries groceries = ['Milk', 'Bread', 'Eggs'] # Overwrite element at index `1` groceries[1] = 'Fruit' # Show that it worked assert groceries == ['Milk', 'Fruit', 'Eggs'] ``` Was nun, wenn wir ein **Element per Index-Zuweisung einfügen** möchten? Wir nutzen eine Slice, die den gewünschten Index als `start`- und `stop`-Wert enthält. Damit die Slice-Zuweisung funktioniert, muss zwingend eine Liste rechts vom Gleichheitszeichen stehen: ```Python # List of groceries groceries = ['Milk', 'Bread', 'Eggs'] # Insert element before index `1` groceries[1:1] = ['Fruit'] # Show that it worked assert groceries == ['Milk', 'Fruit', 'Bread', 'Eggs'] ``` Mit diesem Trick lassen sich sogar **mehrere Elemente auf einmal in eine Python-Liste einfügen** – das kann die `insert()`-Methode nicht: ```Python # List of groceries groceries = ['Milk', 'Bread', 'Eggs'] # Insert elements before index `1` groceries[1:1] = ['Fruit', 'Butter'] # Show that it worked assert groceries == ['Milk', 'Fruit', 'Butter', 'Bread', 'Eggs'] ``` Ferner lassen sich **mit Slice-Zuweisungen selektiv Elemente einer Liste überschreiben**. Insgesamt handelt es sich bei Slices um ein ausgesprochen flexibles Feature, das im Werkzeugkasten aller Python-Programmierenden vorhanden sein sollte. ## Mit List Comprehension Python-Elemente zu einer Liste hinzufügen Ein häufiger Anwendungsfall, bei dem in Python Elemente zu einer Liste hinzugefügt werden sollen, besteht darin, eine **neue Liste mit Elementen zu befüllen**. Der Standard-Ansatz, der in Python wie in den meisten Programmiersprachen funktioniert, sieht so aus: 1. Leere Liste erzeugen 2. Per Schleife Elemente erzeugen 3. Liste um erzeugtes Element erweitern Betrachten wir exemplarisch das **Erzeugen der Liste der ersten zehn Quadratzahlen**: ```Python # Empty list to be filled squares = [] # Successively create numbers 0..9 for n in range(10): # Compute squared number squared = n * n # Append squared number to list squares.append(squared) # Show that it worked assert squares == [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] ``` Es gibt jedoch in Python einen besseren Ansatz. Wir nutzen eine sogenannte **List Comprehension** und erzeugen damit die Liste ohne `for`-Schleife und leere Listen-Variable: ```Python # Create first ten square numbers squares = [n ** 2 for n in range(10)] # Show that it worked assert squares == [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] ``` So elegant sie sind, eignen sich List Comprehensions **nur zum Befüllen einer neuen Liste**. Zum Erweitern einer existierenden Liste greift man auf die bereits vorgestellten Methoden zurück. Tipp Mit [Deploy Now](https://www.ionos.de/hosting/deploy-now "Deploy Now - Websites und Apps via GitHub deployen - IONOS") von IONOS können Sie Websites und Apps via GitHub deployen. This is a markdown version of: [https://www.ionos.de/digitalguide/websites/web-entwicklung/zu-python-liste-hinzufuegen/](https://www.ionos.de/digitalguide/websites/web-entwicklung/zu-python-liste-hinzufuegen/) for AI/LLM consumption.