Listen in Python

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