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.

Im Gegensatz zu einem Array, kann eine Liste 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. Im folgenden Beispiel soll „Jakarta“ keiner Variable zugewiesen werden. Als Bezeichnung wird hier nach dem Sternechen ein Unterstrich (_) verwendet (es wäre aber auch irgendeine andere Bezeichnung möglich):

a, b, *_ = towns
print(a)  # -> Budapest
print(b)  # -> Bagdad

Wie die Ausgabe von _ zeigt, handelt es sich dabei um eine neue Liste, die nur den Wert „Jakarta“ enthält:

print(_)  # -> ["Jakarta"]

Eine Liste durchlaufen

Die Liste my_list könnte folgendermaßen mit einer for-Schleife (for loop) durchlaufen werden. Man spricht hierbei auch von einer Iteration (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']

Die Methoden sind daran zu erkennen, dass keine doppelten Unterstriche vor und nach der Bezeichnung vorhanden sind (z.B. bei append). 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() und der Unpacking Operator

Listen lassen sich auch dergestalt zusammenfügen, dass die Werte paarweise in einem Tupel zusammengefasst 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 (unpacking operator) kann eine Liste mit Tupeln 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)

Der unpacking operator kann auch ohne zip() verwendet werden, um die Elemente einer Liste zu entpacken:

numbers = [50, 22, 101, 39, 27, 4]
print(*numbers)<br># -> 50, 22, 101, 39, 27, 4

Eine Liste kopieren

Ein Liste kann wie folgt mithilfe des Zuweisungsoperators kopiert werden:

first_list = [202, 130, 70, 152]

second_list = first_list

print(first_list)  # -> [202, 130, 70, 152]
print(second_list)  # -> [202, 130, 70, 152]

Beide Listen haben die gleichen Elemente. Aber es ist folgendes zu beachten: Es wird nicht der Inhalt der Liste kopiert, sondern es wird die Referenz kopiert. Beide Listen haben also die gleiche Speicheradresse, was sich mit id() überprüfen lässt:

print(id(first_list))  # -> 4367733696
print(id(second_list))  # -> 4367733696

Es gibt verschiedene Wege, um tatsächlich eine Kopie zu erhalten. So wäre beispielsweise folgendes möglich:

second_list = [i for i in first_list] 

Dadurch erhält man zwei Listen an unterschiedlichen Speicheradressen. Darüber hinaus würde auch folgende Zeile zum Ziel führen:

second_list = first_list[ : ]

Freilich gibt es noch mehr wissenswertes zu Listen. Als weiterführende Lektüre bietet sich ein Blick in die offizielle Dokumentation an.

Weiterführende Links

• Eine Liste in Python sortieren
• Python – Arrays & Listen

Zuletzt aktualisiert am 18. Februar 2025