Python-Listen: Ein umfassender Leitfaden

Diese Seite behandelt alles, was Sie über Python-Listen wissen müssen — wie Sie sie erstellen, ihren Inhalt lesen und ändern, Slicing verwenden, eingebaute Methoden anwenden, List Comprehensions schreiben, mit verschachtelten Listen arbeiten und Listenwerte in Variablen entpacken.

Was ist eine Python-Liste?

Eine Liste ist Pythons vielseitigste eingebaute Datenstruktur. Sie speichert eine geordnete Folge von Elementen, wobei jedes Element einen beliebigen Typ haben kann: eine Zahl, einen string, einen boolean, eine andere Liste oder ein beliebiges Objekt. Listen sind:

• Geordnet — Elemente behalten die Position, die Sie ihnen zuweisen.
• Veränderlich — Sie können Elemente nach der Erstellung der Liste hinzufügen, entfernen oder ändern.
• Indiziert — jedes Element hat einen ganzzahligen Index, der bei 0 beginnt.
• Heterogen — eine einzelne Liste kann Werte unterschiedlicher Typen enthalten.

Erstellen Sie eine Liste mit eckigen Klammern und trennen Sie die Elemente durch Kommas:

Eine leere Liste wird als [] geschrieben. Listen können auch gemischte Typen enthalten:

mixed = [42, 'hello', True, 3.14, None]
print(mixed)
# [42, 'hello', True, 3.14, None]

Auf Listenelemente zugreifen

Positiver Index

Greifen Sie auf ein Element über seine nullbasierte Position in eckigen Klammern zu:

Negativer Index

Negative Indizes zählen rückwärts vom Ende. -1 ist das letzte Element, -2 das vorletzte usw. — nützlich, wenn Sie die Position vom Ende her kennen, aber nicht die Gesamtlänge:

Slicing

Ein Slice extrahiert eine Teilliste mit der Syntax list[start:stop:step]. Der stop-Index ist exklusiv (nicht enthalten).

fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry']

print(fruits[1:4])   # ['banana', 'cherry', 'date']
print(fruits[:2])    # ['apple', 'banana']   — start defaults to 0
print(fruits[2:])    # ['cherry', 'date', 'elderberry'] — stop defaults to end
print(fruits[::2])   # ['apple', 'cherry', 'elderberry'] — every other item
print(fruits[::-1])  # ['elderberry', 'date', 'cherry', 'banana', 'apple'] — reversed copy

Slicing gibt immer eine neue Liste zurück und löst niemals einen IndexError aus, selbst wenn die Indizes außerhalb des Bereichs liegen.

Listenelemente ändern

Da Listen veränderlich sind, können Sie einem beliebigen Index einen neuen Wert zuweisen:

Sie können auch einen Bereich von Elementen durch Slice-Zuweisung ersetzen:

nums = [1, 2, 3, 4, 5]
nums[1:3] = [20, 30]
print(nums)
# [1, 20, 30, 4, 5]

Elemente hinzufügen

append() — Am Ende hinzufügen

append() fügt ein einzelnes Element am Ende der Liste in place ein:

insert() — An einer bestimmten Position hinzufügen

insert(index, value) platziert ein neues Element vor dem angegebenen Index, ohne etwas zu entfernen:

fruits = ['apple', 'banana', 'cherry']
fruits.insert(1, 'mango')
print(fruits)
# ['apple', 'mango', 'banana', 'cherry']

extend() — Mehrere Elemente hinzufügen

extend() hängt alle Elemente aus einem anderen Iterable (Liste, Tupel oder string) an das Ende an:

a = [1, 2, 3]
b = [4, 5, 6]
a.extend(b)
print(a)
# [1, 2, 3, 4, 5, 6]

Der Operator + tut dasselbe, gibt jedoch eine neue Liste zurück, anstatt das Original zu verändern:

combined = [1, 2, 3] + [4, 5, 6]
print(combined)
# [1, 2, 3, 4, 5, 6]

Elemente entfernen

remove() — Nach Wert entfernen

remove() löscht das erste Vorkommen eines Werts. Es wird ein ValueError ausgelöst, wenn der Wert nicht in der Liste vorhanden ist:

pop() — Nach Index entfernen

pop() entfernt das Element an einem bestimmten Index (Standard: letztes Element) und gibt es zurück. Dies ist nützlich, wenn Sie ein Element sowohl abrufen als auch entfernen möchten:

fruits = ['apple', 'banana', 'cherry']
last = fruits.pop()
print(last)    # cherry
print(fruits)  # ['apple', 'banana']

first = fruits.pop(0)
print(first)   # apple
print(fruits)  # ['banana']

del — Nach Index oder Slice löschen

Die del-Anweisung entfernt ein Element nach Index oder einen gesamten Slice:

clear() — Alle Elemente entfernen

clear() leert die Liste, ohne die Liste selbst zu löschen:

fruits = ['apple', 'banana', 'cherry']
fruits.clear()
print(fruits)
# []

Nützliche Listenmethoden

Python-Listen verfügen über einen vollständigen Satz eingebauter Methoden. Siehe Python-Listenmethoden für die vollständige Referenz.

len() — Länge der Liste

sort() — In place sortieren

sort() sortiert die Liste standardmäßig in aufsteigender Reihenfolge. Verwenden Sie reverse=True für absteigende Reihenfolge:

Verwenden Sie den Parameter key, um nach einem benutzerdefinierten Kriterium zu sortieren — zum Beispiel nach Wortlänge:

words = ['banana', 'apple', 'cherry', 'date']
words.sort(key=len)
print(words)
# ['date', 'apple', 'banana', 'cherry']

sort() verändert die Liste in place. Um eine sortierte Kopie zu erhalten, ohne das Original zu ändern, verwenden Sie die eingebaute Funktion sorted():

original = [3, 1, 2]
s = sorted(original)
print(original)  # [3, 1, 2]
print(s)         # [1, 2, 3]

Siehe Listen sortieren für weitere Sortiermuster.

reverse() — In place umkehren

count() — Vorkommen zählen

count(value) gibt zurück, wie oft ein Wert vorkommt:

nums = [1, 2, 2, 3, 2, 4]
print(nums.count(2))
# 3

index() — Einen Wert suchen

index(value) gibt den Index des ersten Vorkommens zurück. Es wird ein ValueError ausgelöst, wenn der Wert nicht gefunden wird:

nums = [1, 2, 3, 4]
print(nums.index(3))
# 2

copy() — Flache Kopie

copy() gibt eine neue Liste mit denselben Elementen der obersten Ebene zurück. Das Ändern der Kopie wirkt sich nicht auf das Original aus:

original = [1, 2, 3]
copy = original.copy()
copy.append(4)
print(original)  # [1, 2, 3]
print(copy)      # [1, 2, 3, 4]

Sortieren vs. Umkehren: Wichtiger Unterschied

sort() und reverse() verändern die Liste beide in place und geben None zurück. Ein häufiger Fehler ist my_list = my_list.sort(), wodurch die Liste durch None ersetzt wird. Rufen Sie diese Methoden immer als Anweisungen auf:

fruits = ['banana', 'apple', 'cherry']
fruits.sort()   # correct — modifies in place
# fruits = fruits.sort()  # wrong — sets fruits to None
print(fruits)
# ['apple', 'banana', 'cherry']

Verschachtelte Listen

Eine Liste kann andere Listen als Elemente enthalten und so eine 2D- (oder tiefere) Struktur bilden:

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]

print(matrix[0])     # [1, 2, 3]
print(matrix[1][2])  # 6  — row 1, column 2

Verschachtelte Listen werden häufig zur Darstellung von Rastern, Tabellen und Matrizen verwendet.

List Comprehensions

Eine List Comprehension ist ein kompakter einzeiliger Ausdruck zum Aufbau einer neuen Liste durch Transformierung oder Filterung eines vorhandenen Iterables. Die Syntax lautet:

[expression for item in iterable if condition]

Der Teil if condition ist optional.

Quadratzahlen von 1–10:

Nur gerade Zahlen:

evens = [x for x in range(1, 11) if x % 2 == 0]
print(evens)
# [2, 4, 6, 8, 10]

Strings transformieren:

fruits = ['apple', 'banana', 'cherry']
upper = [f.upper() for f in fruits]
print(upper)
# ['APPLE', 'BANANA', 'CHERRY']

List Comprehensions sind im Allgemeinen schneller als eine äquivalente for-Schleife mit append(). Siehe List Comprehension für erweiterte Muster.

Listen entpacken

Sie können Listenelemente in einem Schritt einzelnen Variablen zuweisen:

a, b, c = ['x', 'y', 'z']
print(a, b, c)
# x y z

Der *-Operator (Stern) erfasst eine beliebige Anzahl verbleibender Elemente:

first, *rest = [1, 2, 3, 4, 5]
print(first)  # 1
print(rest)   # [2, 3, 4, 5]

Das Entpacken löst einen ValueError aus, wenn die Anzahl der Variablen nicht mit der Anzahl der Elemente übereinstimmt (es sei denn, Sie verwenden *).

Wann eine Liste verwenden?

Übungen