Fachkonzept - Liste

Listen und ihre Darstellung

Listen können in fast allen Programmiersprachen zur Verwaltung von Daten benutzt werden. Die Art und Weise, wie Listen in verschiedenen Programmiersprachen zusammengesetzt sein dürfen, wie sie dargestellt werden und wie sie mit Operationen verändert werden können, unterscheidet sich aber zum Teil recht deutlich. Wir benutzen im Folgenden natürlich das Listenkonzept von Python. Statt PyGame-Zero-Objekte verwenden wir in diesem Abschnitt einfach Zeichen, Zeichenfolgen oder Buchstaben, weil man die Programme dann schneller testen kann.

Zur Darstellung von Listen verwenden wir eckige Klammern. Alle Elemente einer Liste werden mit Kommata getrennt.

Zugriff auf Elemente einer Liste

Die Elemente einer Liste sind durchnummeriert. Beachte, dass die Nummerierung mit 0 beginnt. Die Nummer eines Elements wird auch Index genannt.

Der Zugriff erfolgt über die Nummer bzw. den Index des Listenelements. Wenn L eine Liste bezeichnet, dann beschreibt der Ausdruck L[i] das Listenelement mit der Nummer i.

>>> L = ['a', 'b', 'c', 'd', 'e']
>>> L[0]
'a'
>>> L[1]
'b'

Bei Listen ist sowohl ein lesender Zugriff als auch ein schreibender Zugriff auf die Elemente möglich.

>>> L = ['a', 'b', 'c', 'd', 'e']
>>> L[4]
'e'
>>> L[4] = 'g'
>>> L
['a', 'b', 'c', 'd', 'g']

Listen unterschiedlicher Datentypen

Die Elemente einer Liste können von beliebigem - also auch unterschiedlichem - Typ sein. Sie können sogar selbst wiederum Listen enthalten.

Beispiele:

# Liste zur Verwaltung von E-Mailadressen
['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de'] 
# Liste zur Verwaltung von Lottozahlen
[1, 12, 21, 31, 37, 46]
# Liste zur Verwaltung erzielter Tore
['Lukas Podolski', 14]
# Liste zur Verwaltung von Personendaten
['Lisa', 'Schmitz', [25, 2, 1995]]

Das Beispiel ['Lisa', 'Schmitz', [25, 2, 1995]] zeigt, dass eine Liste selbst wieder Listen als Elemente haben kann. Listen können also geschachtelt werden.

Leere Liste und Anhängen von Listenelementen

Bei den vorhergehenden Beispielen wurden die Listen einmal durch die Angabe der verschiedenen Listenelementen in eckigen Klammern beschrieben. Alternativ dazu kann man die Elemente auch nach und nach anhängen. Hierzu muss aber zunächst überhaupt eine Liste bestehen. Diese kann jedoch auch eine leere Liste sein, markiert durch ein eckiges Klammernpaar ohne Inhalt dazwischen. Der Code

L = ['a', 'b', 'c', 'd', 'e']

könnte auch geschrieben werden als:

# Leere Liste (Liste ohne Listenelemente)
L=[]
# Schrittweises Anhängen der Listenelemente
L.append('a')
L.append('b')
L.append('c')
L.append('d')
L.append('e')

Zugriff auf Teillisten

Ein Zugriff auf eine Teilliste ist wie folgt möglich: Wenn L eine Liste bezeichnet, dann beschreibt der Ausdruck L[i:j] die Liste, die alle Elemente der Ausgangsliste L mit den Nummern von i bis j-1 enthält. Beachte, dass diese Teilliste auch leer sein kann.

>>> L = ['g', 't', 'e', 'c', 's', 'k', 'p']
>>> L[0:2]
['g', 't']
>>> L[2:5]
['e', 'c', 's']
>>> L[1:5]
['t', 'e', 'c', 's']
>>> L[3:3]
[]

Die folgenden Beispiele zeigen noch einige abkürzende Schreibweisen, die die Beschreibung von Teillisten oft vereinfachen.

>>> L = ['g', 't', 'e', 'c', 's', 'k', 'p']
>>> L[2:]
['e', 'c', 's', 'k', 'p']
# von Nummer 2 bis zum Ende der Nummerierung
>>> L[:2]
['g', 't']
# von Nummer 0 bis zur Nummer 2-1
>>> L[:]
['g', 't', 'e', 'c', 's', 'k', 'p']
# von Nummer 0 bis zum Ende der Nummerierung

Aneinanderhängen (Fachwort: "Konkatenation") von Listen

Bei der Konkatenation von Listen werden diese zu einer Gesamtliste verbunden. Wenn L und M zwei Listen bezeichnen, dann beschreibt der Ausdruck L+M die Liste, die zunächst alle Elemente von L und danach alle Elemente von M enthält.

>>> L = ['g', 't', 'e', 'c', 's', 'k', 'p']
>>> M = ['a', 'g', 't']
>>> L + M
['g', 't', 'e', 'c', 's', 'k', 'p', 'a', 'g', 't']
>>> L + ['u']
['g', 't', 'e', 'c', 's', 'k', 'p', 'u']
>>> [] + M
['a', 'g', 't']

Vorhandensein in einer Liste abprüfen

Mit einem Ausdruck der Gestalt e in L kann man überprüfen, ob das von e verwaltete Datenobjekt in der von L verwalteten Liste vorkommt.

>>> L = ['g', 't', 'e', 'c', 's', 'k', 'p']
>>> e = 'a'
>>> e in L
False
>>> e = 's'
>>> e in L
True