Zu Python-Liste hin­zu­fü­gen

Listen sind grund­le­gen­de Da­ten­struk­tu­ren in der In­for­ma­tik. Viele Al­go­rith­men beruhen darauf, Listen zu mo­di­fi­zie­ren. Wir zeigen, wie sich in Python Elemente zu einer Liste hin­zu­zu­fü­gen lassen.

Wie lassen sich Elemente zu einer Python-Liste hin­zu­fü­gen?

Anders als Tupel und Strings sind Listen in Python „mutable“, d. h. ver­än­der­ba­re Da­ten­struk­tu­ren. Wir können Elemente zu einer Python-Liste hin­zu­fü­gen, Elemente entfernen und die Rei­hen­fol­ge der Elemente ändern. Dazu gibt es ver­schie­de­ne 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 hin­zu­fü­gen können:

1. Mit den Python-list-Methoden Elemente zu einer Liste hin­zu­fü­gen
2. Mit Listen-Kon­ka­te­na­ti­on in Python Elemente zu einer Liste hin­zu­fü­gen
3. Mit Slice-Notation Elemente in Python zu einer Liste hin­zu­fü­gen
4. Mit List Com­pre­hen­si­on Python-Elemente zu einer Liste hin­zu­fü­gen

Mit den Python-list-Methoden Elemente zu einer Liste hin­zu­fü­gen

In Python dient die Klasse list als Grundlage für sämtliche Listen-Ope­ra­tio­nen. Die Klasse definiert eine Reihe von Methoden für Listen-Objekte. Dazu gehören drei Methoden, die sich zum Hin­zu­fü­gen von Elementen zu einer Liste eignen:

Wichtig zu verstehen ist, dass die Ver­än­de­rung bei den drei genannten Methoden „in-place“ erfolgt. Das bedeutet, dass das Listen-Objekt verändert wird, anstatt eine neue Liste zu erzeugen und zu­rück­zu­ge­ben. Kon­se­quen­ter­wei­se 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 hin­zu­fü­gen

Mit der Python-append()-Methode lässt sich ein einzelnes Element zum Ende einer be­stehen­den Liste hin­zu­fü­gen. Ver­an­schau­li­chen 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 hin­zu­zu­fü­gen­den Element um eine weitere Liste, entsteht eine ver­schach­tel­te 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 fehl­ge­schla­gen. Um mehrere Elemente hin­zu­zu­fü­gen, nutzen wir besser die extend()-Methode.

Mit extend() Elemente zum Ende der Liste hin­zu­fü­gen

Die Python-extend()-Methode funk­tio­niert ähnlich wie append(), mit dem Un­ter­schied, dass einer be­stehen­den Liste mehrere Elemente hin­zu­ge­fügt werden. Be­trach­ten wir zum Ver­ständ­nis 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 über­ra­schen­dem 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 hin­zu­zu­fü­gen, nutzt man entweder append() oder schließt das Element mit eckigen Klammern in eine Liste ein. Dann funk­tio­niert 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 an­ge­ge­be­nen Index hin­zu­fü­gen

Bisher haben wir gezeigt, wie sich ein oder mehrere Elemente zum Ende einer Python-Liste hin­zu­fü­gen lassen. Was jedoch, wenn wir ein Element an einer be­lie­bi­gen Position einfügen möchten? Genau für diesen Fall gibt es die Python-insert()-Methode. Diese nimmt zu­sätz­lich zum ein­zu­fü­gen­den Element einen nu­me­ri­schen 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() hin­zu­zu­fü­gen – da insert() genau ein Element einfügt, erzeugen wir ungewollt eine ver­schach­tel­te 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 ein­zu­fü­gen, nutzen wir eine for-Schleife. Ferner bedienen wir uns der reversed()-Funktion, um die Rei­hen­fol­ge der ein­ge­füg­ten Elemente bei­zu­be­hal­ten:

# 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-Kon­ka­te­na­ti­on in Python Elemente zu einer Liste hin­zu­fü­gen

Neben den vor­ge­stell­ten list-Methoden existiert mit der Listen-Kon­ka­te­na­ti­on eine weitere Mög­lich­keit, einer Python-Liste Elemente hin­zu­zu­fü­gen. Dabei kommt der Python +-Operator zum Einsatz. Die Listen-Kon­ka­te­na­ti­on ent­spricht in etwa der Nutzung von extend(). Jedoch erzeugt die Kon­ka­te­na­ti­on 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 zu­rück­gibt, weisen wir den Rück­ga­be­wert 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 Kon­ka­te­na­ti­ons-Operator die __add__()-Methode auf. Die Ausdrücke guys + gals und guys.__add__(gals) sind also äqui­va­lent:

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

Falls Sie sich mit den Python-Ope­ra­to­ren auskennen, ahnen Sie es viel­leicht bereits. Die Listen-Kon­ka­te­na­ti­on un­ter­stützt auch das Augmented As­sign­ment. Dabei kommt der +=-Operator zum Einsatz, um Elemente zu einer Liste „in-place“ hin­zu­zu­fü­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 mo­di­fi­ziert. Die folgenden Zeilen sind also äqui­va­lent:

• groceries = groceries + ['Butter']
• groceries += ['Butter']
• groceries.__iadd__(['Butter'])
• groceries.extend(['Butter'])

Vorsicht gilt, wenn die Listen-Kon­ka­te­na­ti­ons-Ope­ra­to­ren zum Einsatz kommen, um einer Liste ein einzelnes Element hin­zu­zu­fü­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 ein­ele­men­ti­gen Liste führt zum wahr­schein­lich ge­wünsch­ten Effekt, der Liste eine weitere Stadt hin­zu­zu­fü­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 hin­zu­fü­gen

Slices sind ein Python-Feature zum Auswählen auf­ein­an­der­fol­gen­der Elemente einer Liste. Die Syntax von Slices ent­spricht 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 Ver­bin­dung mit dem Index-Operator []:

# Select items of list
lst[start:stop:step]

Ein Slice-Objekt lässt sich anstelle eines nu­me­ri­schen Index verwenden, um mehrere Elemente einer Sequenz aus­zu­wäh­len:

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 Kom­bi­na­ti­on mit Zu­wei­sun­gen lassen sich Slices als Al­ter­na­ti­ve für die list-Methoden append(), extend() und insert() verwenden:

Um zu verstehen, wie das funk­tio­niert, be­trach­ten wir zunächst die Zuweisung eines Listen-Elements per nu­me­ri­schem Index. Dabei wird ein einzelnes Listen-Element über­schrie­ben:

# 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 ge­wünsch­ten Index als start- und stop-Wert enthält. Damit die Slice-Zuweisung funk­tio­niert, muss zwingend eine Liste rechts vom Gleich­heits­zei­chen 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-Zu­wei­sun­gen selektiv Elemente einer Liste über­schrei­ben. Insgesamt handelt es sich bei Slices um ein aus­ge­spro­chen flexibles Feature, das im Werk­zeug­kas­ten aller Python-Pro­gram­mie­ren­den vorhanden sein sollte.

Mit List Com­pre­hen­si­on Python-Elemente zu einer Liste hin­zu­fü­gen

Ein häufiger An­wen­dungs­fall, bei dem in Python Elemente zu einer Liste hin­zu­ge­fügt werden sollen, besteht darin, eine neue Liste mit Elementen zu befüllen. Der Standard-Ansatz, der in Python wie in den meisten Pro­gram­mier­spra­chen funk­tio­niert, sieht so aus:

1. Leere Liste erzeugen
2. Per Schleife Elemente erzeugen
3. Liste um erzeugtes Element erweitern

Be­trach­ten wir ex­em­pla­risch das Erzeugen der Liste der ersten zehn Qua­drat­zah­len:

# 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 so­ge­nann­te List Com­pre­hen­si­on 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 Com­pre­hen­si­ons nur zum Befüllen einer neuen Liste. Zum Erweitern einer exis­tie­ren­den Liste greift man auf die bereits vor­ge­stell­ten Methoden zurück.