Einführung
In Python existiert die Datenstruktur Liste. Es handelt sich dabei um eine
- veränderbare (mutable)
- Sequenz
von Elementen. Realisiert wird dieser abstrakte Datentyp mithilfe einer Array-Struktur. Auch wenn in Python die Begriffe Array und List synonym verwendet werden, handelt es sich dennoch um zwei unterschiedliche Datenstrukturen.
Für das Erzeugen einer leeren Liste existieren zwei Möglichkeiten. Zum einen durch den Aufruf des list constructors list()
:
my_list = list()
Zum anderen mithilfe der eckigen Klammern []
:
my_list = []
Freilich kann auch eine Liste mit Werten erzeugt werden:
my_numbers = [75, 10, 23, 91, 4, 38, 50]
Das erste Element hat den Index 0, das letzte Element hat (hier) den Index 6. Andersherum betrachtet, hat das letzte Element den Index -1, das erste Element (hier) den Index -7.

Eine Liste kann Daten unterschiedlichen Typs beinhalten. Folgender Code — eine Liste mit Werten der Datentypen int
, string
und float
— wäre also problemlos möglich:
my_list = [200, "Hello!", 13.8]
print(my_list) # -> [200, 'Hello!', 13.8]
Elemente einer Variablen zuweisen
Das Element einer Liste kann über den Index einer Variable zugewiesen werden. Betrachten wir dazu folgende Liste mit Städtenamen:
towns = ["Budapest", "Bagdad", "Jakarta"]
a = towns[0] # -> Budapest
b = towns[1] # -> Bagdad
c = towns[2] # -> Jakarta
In Python besteht darüber hinaus die Möglichkeit, eine Liste zu entpacken. Die Elemente einer Liste können mehreren Variablen zugewiesen werden (dies ist übrigens auch bei Tupeln möglich):
a, b, c = towns
print(a) # -> Budapest
print(b) # -> Bagdad
print(c) # -> Jakarta
Sofern nur bestimmte Elemente von Interesse sind, können die übrigen Elemente mit einem Sternchen (*
) gekennzeichnet werden. Sie werden Bestandteil einer neuen Liste. Im folgenden Beispiel ist dies bei „Jakarta“ der Fall. Als Bezeichnung wird hier einfach ein Unterstrich (_
) verwendet (es wäre aber auch irgendeine andere Bezeichnung möglich).
a, b, *_ = towns
print(a) # -> Budapest
print(b) # -> Bagdad
Die Ausgabe von _
bestätigt, dass es sich tatsächlich um eine neue Liste mit nur einem Wert handelt:
print(_) # -> ["Jakarta"]
Eine Liste durchlaufen
Die Liste my_list
könnte nun folgendermaßen mit einer for-Schleife (for loop) durchlaufen werden. Man bezeichnet dies auch als Iterieren (lat.: iterare , wiederholen):
for value in my_list:
print(value)
200
Hello!
13.8
Die for-Schleife kann auch zusammen mit der Built-in-Funktion enumerate()
kombiniert werden. Im folgenden Beispiel werden so die Werte zusammen mit den Indizes ausgegeben:
for i, value in enumerate(my_list):
print(i, value)
0 200
1 Hello!
2 13.8
Zur Verfügung stehende Methoden
Wenn man
dir(list)
ausführt, dann kann man anhand der Rückmeldung sehen, dass es sich um eine Klasse handelt, die einige Methoden bereitstellt:
['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__',
'__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__',
'__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__',
'__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index',
'insert', 'pop', 'remove', 'reverse', 'sort']
Einige dieser Methoden werden nachfolgend vorgestellt.
Elemente hinzufügen
Am bekanntesten dürfte vermutlich append()
sein, mit der ein Element zu einer Liste hinzugefügt werden kann. Zum Ausführen der Methode wird die Punkt-Notation verwendet. Das bedeutet, dass die Methode nach einem Punkt an den Listen-Bezeichner “angehängt” wird:
numbers_list.append(20) # -> [75, 10, 23, 91, 4, 38, 50, 20]
Elemente entfernen
Zum entfernen eines Elements steht pop()
zur Verfügung. Ohne die Angabe eines Index wird stets das letzte Element entfernt. Im folgenden Beispiel wird der letzte Wert 50 entfernt und einer neuen Variable last_item
zugewiesen:
my_numbers = [75, 10, 23, 91, 4, 38, 50]
last_item = my_numbers.pop() # -> 50
Die Liste my_numbers
enthält nun die Werte
[75, 10, 23, 91, 4, 38]

Wie bereits erwähnt, kann durch die Angebe eines Index der zu entfernende Wert festgelegt werden. Im folgenden Beispiel wird der zu Index 0 korrespondierende Wert (hier: 75) entfernt:
my_numbers.pop(0) # erstes Element entfernen
Darüber hinaus existiert die Methode remove()
. Soll aus der Liste der Wert 23 entfernt werden, kann dies mit
my_numbers.remove(23)
umgesetzt werden.
Elemente einfügen
Für das Einfügen eines Elements ist die Methode insert()
zu verwenden. Um den Wert 30 an der Position des zweiten Index einzufügen, ist folgender Code erforderlich:
my_numbers = [75, 10, 23, 91, 4, 38, 50]
my_numbers.insert(2, 30)
print(my_numbers) # -> [75, 10, 30, 23, 91, 4, 38, 50]

Alle nachfolgende Werte verschieben sich dabei um einen Index.
Eine Liste erweitern
Mit extend()
ist es möglich, eine Liste um eine andere Liste zu erweitern. Angenommen es existieren zwei Listen first_list
und second_list
:
first_list = [75, 10, 23]
second_list = [63, 90, 8]
Dann kann die erste Liste wie folgt um die zweite Liste erweitert werden:
first_list.extend(second_list)
print(first_list) # -> [75, 10, 23, 63, 90, 8]

Eine Liste sortieren
Die Methode sort()
übernimmt das Sortieren einer Liste:
numbers = [22, 50, 1, 23, 17, 12]
numbers.sort()
print(numbers) # -> [1, 12, 17, 22, 23, 50]
Darüber hinaus existiert auch noch die Funktion sorted()
:
x = [101, 27, 53, 18, 4, 67]
y = sorted(x)
print(y) # -> [4, 18, 27, 53, 67, 101]
Der Unterschied besteht darin, dass die Methode sort()
nur für Listen definiert ist. Dagegen funktioniert die Funktion sorted()
auch bei anderen Datenstrukturen, die iterierbar sind (z.B. string
, tuple
, set
, dictionary
).
Die Funktion sorted()
akzeptiert auch Parameter. So kann mit reverse
festgelegt werden, ob auf- oder absteigend sortiert werden soll:
z = sorted(x, reverse=True)
print(z) # -> [101, 67, 53, 27, 18, 4]
Eine Liste umkehren
Die Reihenfolge der Elemente einer Liste kann mit reverse()
umgekehrt werden:
numbers = [0, 1, 2, 3, 4, 5] # -> [5, 4, 3, 2, 1, 0]
numbers.reverse()
Hierbei ist zu beachten, dass reverse()
keine neue Liste zurückgibt, sondern None
.
numbers = [0, 1, 2, 3, 4, 5]
reversed_numbers = numbers.reverse()
print(reversed_numbers)
# -> None
Die Funktion zip()
Mehrere Listen können auf einfache Weise zu einer Liste zusammengefügt werden. Dafür steht die Funktion zip()
zur Verfügung:
given_name = ['Tim', 'Julia', 'Kendra', 'Denise']
age = [32, 31, 28, 40]
print(list(zip(given_name, age)))
# -> [('Tim', 32), ('Julia', 31), ('Kendra', 28), ('Denise', 40)]
Mit zip()
und dem *
-Operator kann eine Liste auch wieder entpackt werden:
given_name_and_age = [
('Tim', 32),
('Julia', 31),
('Kendra', 28),
('Denise', 40)
]
given_name, age = zip(*given_name_and_age)
print(f"given name: {given_name}\nage: {age}")
# -> given name: ('Tim', 'Julia', 'Kendra', 'Denise')
# -> age: (32, 31, 28, 40)
Freilich gibt es noch mehr wissenswertes zu Listen. Als weiterführende Lektüre bietet sich ein Blick in die offizielle Dokumentation an. Außerdem habe ich zu diesem Thema ein Youtube-Video veröffentlicht.
Zuletzt aktualisiert am 25. August 2022