Integrierte Datentypen – Listen

Datentyp-Hierarchie (Wiederholung)

Zu Deiner besseren Orientierung zeige ich hier nochmals die Datentyp-Hierarchie von Python. Die Zahlendatentypen und Wahrheitswerte haben wir den vorangegangenen Abschnitten behandelt. Jetzt widmen wir uns den Listen.

Listen

Listen, Datentyp list, sind veränderbare Datenstrukturen, bei denen, wie der Name es nahelegt, Datenelemente in einer Sequenz aneinandergereiht sind. Bezüglich anderer Programmiersprachen, sowie in der Informatik im Allgemeinen, sprechen wir bei einer Liste auch von einem Array. Allerdings ist eine Liste in Python vielfach deutlich mächtiger als die Arrays anderer Programmiersprachen. Eine Liste ist nämlich nicht nur eine bloße Datenstruktur, sie besitzt allerlei Funktionalität.

Grafisch kannst Du Dir eine Liste wie folgt visualisieren:

Bei vielen Programmiersprachen müssen die Datenelemente von jeweils gleichem Datentyp sein. In Python können beliebige Datentypen in einer Liste gemischt auftreten. Es ist nicht sinnvoll, sich vorzustellen, die Daten würden „in“ der Liste gespeichert. Vielmehr beinhaltet jedes Listenelement einen Verweis auf einen Datenobjekt.

Jedes Datenelement besitzt einen Indexwert. Dieser beginnt bei Null. Eine Liste mit n Elementen hat also Indizes von 0 bis n-1. Das Wissen um die Indexierung ist wichtig, um auf einzelne oder auch mehrere Listenelemente gezielt zugreifen zu können. Der Zugriff auf ein nicht existierendes Listenelement ist ein Fehler!

>>> [1, 2, 3]
    [1, 2, 3]
>>> ["Erstes Element", -3.14, True, [1, 2, 3], 'A', 42]
    ["Erstes Element", -3.14, True, [1, 2, 3], 'A', 42]

Eine Liste wird literal in eckigen Klammern notiert. Eine Liste [], die keine Datenelemente enthält, ist eine leere Liste. Listen können Elemente beliebiger Datentypen enthalten, auch Listen.

Mittels sogenannten Slicings greifen wir auf Listenelemente zu. Um dies bequem tun zu können, geben wir unserer Beispielliste einen Namen. Innerhalb des Slicing-Operators, den eckigen Klammern, wird der Index des Listenelements angegeben, auf welches zugegriffen werden soll.

>>> liste = ["Erstes Element", -3.14, True, [1, 2, 3], 'A', 42]
>>> liste
    ["Erstes Element", -3.14, True, [1, 2, 3], 'A', 42]
>>> liste[0]
    'Erstes Element'
>>> liste[5]
    42
>>> liste[6]        # FEHLER: Es gibt kein Element mit dem Index 6
    Traceback (most recent call last):
      File "<pyshell#6>", line 1, in <module>
        liste[6]
    IndexError: list index out of range

Der hier verwendete Variablenbezeichner lautet liste. Durch Zuweisung, dem einfachen Gleichheitszeichen, wird daraus eine Variable, welche den zugewiesenen Wert, hier die Liste, referenziert. An Index-Position 0 befindet sich die Zeichenkette "Erstes Element". Der letzte gültige Index der Liste ist5. Die Liste besitzt 6 Elemente, nummeriert von 0 bis einschließlich 5. Der versuchte Zugriff auf ein Listenelement mit dem Index 6 schlägt fehl. Ein solches Element gibt es nicht.

Durch die Angabe eines Start- und eines End-Indizes, kannst Du Bereiche in einer Liste adressieren. Dabei ist der End-Index um 1 weitergehend anzugeben als der Index, auf den tatsächlich zugegriffen werden soll.

>>> liste[0:3]
    ['Erstes Element', -3.14, True]
>>> liste[1:3]
    [-3.14, True]

Die Angabe des End-Indizes mag Dir seltsam erscheinen, macht aber Sinn, wenn Du Dir die len()-Funktion ansiehst, die Python anbietet, um die Länge von Sequenzen oder die Mächtigkeit von Kollektionen zu ermitteln. Mit ihr kannst Du die Länge einer Liste bestimmen. Möctest Du eine Liste von einem bestimmten Index bis zu ihrem Ende ausgeben, setzt Du den Wert ein, der Dir von len() zurückgegeben wird. Dieser ist um 1 größer als der größte zulässige Listen-Index.

>>> len(liste)
    6
>>> liste[2:6]
    [True, [1, 2, 3], 'A', 42]
>>> liste[2:len(liste)]
    [True, [1, 2, 3], 'A', 42]
>>> liste[2:]
    [True, [1, 2, 3], 'A', 42]

Statt des expliziten Werts 6 kann auch der Funktionsaufruf eingesetzt werden. Er liefert den Wert 6. Python erlaubt eine Kurzschreibweise, um das Ende einer Liste zu adressieren. Man lässt den Indexwert einfach aus. Analoges gilt für den Listenanfang.

>>> liste[:3]
    ['Erstes Element', -3.14, True]
>>> liste[:]
    ['Erstes Element', -3.14, True, [1, 2, 3], 'A', 42]

Kombinieren wir das Weglassen des ersten und letzten Indizes, erhalten wir die gesamte Liste.

Last but not least, können wir auch mehrere Elemente aus einer Liste auslesen, die nicht direkt aufeinander folgen. Dafür existiert als dritte Angabe die Schrittweite. Wird sie ausgelassen, wie wir das bisher getan haben, wird als Schrittweite 1 angenommen.

>>> liste[::1]
    ['Erstes Element', -3.14, True, [1, 2, 3], 'A', 42]
>>> liste[::2]
    ['Erstes Element', True, 'A']
>>>> liste[::3]
    ['Erstes Element', [1, 2, 3]]

Interessante Effekte treten bei negativen Indexwerten auf.

>>> liste[-1]
    42
>>> liste[0:-2]
    ['Erstes Element', -3.14, True, [1, 2, 3]]
>>> liste[::-1]
    [42, 'A', [1, 2, 3], True, -3.14, 'Erstes Element']
>>> liste[-4:-2]
    [True, [1, 2, 3]]

Ein negatives Vorzeichen kehrt die Richtung des Listenzugriffes um. Insgesamt sind die Slicing-Operationen in Python sehr mächtig.

Soll auf eine Liste innerhalb einer Liste zugegriffen werden, so erfolgt dies folgerichtig ebenfalls mittels des Slicings-Operators. Mach Dir dazu klar, dass ein Listenelement, welches eine Liste ist, eben auch wie eine Liste behandelt werden muss. Mit liste[3] hast Du eine Liste in der Hand. Um auf deren Element zugreifen zu können, musst Du die mittels des Slicing-Operators tun, also ein Paar eckiger Klammer anfügen.

>>> liste[3][0]
    1
>>> liste[3][1]
    2

Sind Listen in Listen geschachtelt, sprechen wir auch von mehrdimensionalen Listen. Eine Liste mit nur einer Dimension wird auch als Vektor bezeichnet. Eine Liste mit zwei Dimensionen wird dann auch Matrix genannt. Die Anzahl der Dimensionen ist nicht begrenzt. In der Praxis finden Matrizen noch sehr häufig Anwendung. 3-dimesnionale Listen sind schon seltener. Noch mehr Dimensionen findest Du fast nie.

Die Operatoren + und * sind für Listen überladen.+ dient zum Verketten, * vervielfacht eine Liste.

>>> liste = [1] + [2, 3]
>>> liste
    [1, 2, 3]
>>> liste = liste * 3
>>> liste
    [1, 2, 3, 1, 2, 3, 1, 2, 3]

Listen können bei Zuweisung durch Aufzählung Ihrer Elemente mit Daten befüllt werden. Alternativ können Listen mithilfe von Beschreibungen gefüllt werden, die sich an die beschreibende Mengennotation der Mathematik anlehnen. Das nennt man eine Comprehension. In Bezug auf Listen sprechen wir von einer List Comprehension.

Beispiel: „Erzeuge eine Liste \(l\) von Elementen, mit der Eigenschaft \(i^2\) für alle \(i \in [1, 10]\).“

>>> l = [i**2 for i in range(1, 11)]
>>> l
    [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Verändern eines Datenelements in einer Liste

Weil Listen veränderlich sind, können wir deren Datenelemente ändern, sie andere Werte referenzieren lassen.

>>> l = [1, 2, 3, 4, 5]
>>> l
    [1, 2, 3, 4, 5]
>>> l[4] = 500
>>> l
    [1, 2, 3, 4, 500]

Verändern der Datenelemente eines Teilbereichs einer Liste

>>> l[1:4] = [200, 300, 400]
>>> l
    [1, 200, 300, 400, 500]
>>> l[1:1] = [200, 250, 299]  # WICHTIG: Bereich angeben!
>>> l
    [1, 200, 250, 299, 200, 300, 400, 500]

Löschen einzelner Datenelemente oder Teilbereiche einer Liste

Mit del kannst Du ein einzelnes Datenelement oder auch ganze Bereiche einer Liste löschen. Dazu beschreibst Du mithilfe des Slicings, welche Elemente zu entfernen sind.

>>> l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> l
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> del l[::2]
>>> l
    [1, 3, 5, 7, 9]

Methoden von Listen

Im Folgenden seien s und t Listen. i sei ein ganzzahliger Index und x eine Instanz eines beliebigen Datentyps.

Methode	Ergebnis
s.append(x)	Element x an s anfügen
s.extent(t)	liste t an s anfügen
s.insert(i, x)	x an Stelle i in s einfügen
s.pop([i])	Letztes Element oder Element an Stelle i (wenn angegeben) liefern; Element wird aus s entfernt
s.remove(x)	Erstes Vorkommen von x aus s entfernen
s.reverse()	Reihenfolge der Element in s umkehren
s.sort([[key], [reverse]])	s sortieren

Hinweis: Das Sortieren einer Liste setzt eine Ordnungsrelation zwischen den Listenelementen voraus. Mittels key kannst Du optional den Sortierschlüssel angeben. Das kann auch eine Funktion sein – wir behandeln das später. Der ebenfalls optionale Parameter reverse ist standardmäßig mit False belegt. Setzt Du ihn auf True, entspricht das der Methode reverse().

>>> liste = [1, 2, 3, 4, 5]
>>> liste.sort(reverse=True)
>>> liste
    [5, 4, 3, 2, 1]