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 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:

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:

# 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 lässt sich ein einzelnes Element zum Ende einer bestehenden Liste hinzufügen. Veranschaulichen wir uns das Verhalten an einem Beispiel:

# 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:

# 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 funktioniert ähnlich wie append(), mit dem Unterschied, dass einer bestehenden Liste mehrere Elemente hinzugefügt werden. Betrachten wir zum Verständnis wiederum ein Beispiel:

# 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:

# 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():

# 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. Diese nimmt zusätzlich zum einzufügenden Element einen numerischen Index entgegen:

# 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:

# 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:

# 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:

# 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:

# Show that both expressions return the same result
assert guys + gals == guys.__add__(gals)

Falls Sie sich mit den 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:

# 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:

# 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:

# 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:

# 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 []:

# 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:

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:

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:

# 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:

# 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:

# 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:

# 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:

# 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.