Fachkonzept - Liste

Listen und ihre Darstellung

Eine Liste ist eine endliche Folge von Elementen, bei der man flexibel neue Elemente hinzufügen und vorhandene Elemente entfernen kann.

Listen können in fast allen Programmiersprachen zur Verwaltung von Daten benutzt werden. Die Art und Weise, wie diese 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 deutlich. Wir lehnen uns im Folgenden stark an das Listenkonzept von Python an.

• Zur Darstellung von Listen verwenden wir - wie in Python - eckige Klammern.
• Alle Elemente einer Liste werden mit Kommata getrennt.
• Eine besondere Liste ist die leere Liste. Sie enthält keine Elemente.
• Die Elemente einer Liste können (in unserer Darstellung hier) von beliebigem - also auch unterschiedlichem - Typ sein.
• Eine Liste kann selbst wieder Listen als Elemente haben. Listen können also geschachtelt werden.

Die folgenden Beispiele zeigen den Anfang einer Mailingliste, eine Liste mit Zahlen, die leere Liste, eine Liste zur Darstellung einer Lottoziehung und einen Liste zur Darstellung eines Tippscheins mit drei Tipps.

['amueller@gmx.de', 'carla2@hotmail.org', 'herbert.fluhr@web.de', ...] 
[1, 12, 21, 31, 37, 46]
[]
[1, 21, 25, 40, 44, 45, ("Zusatzzahl", 3), ("Superzahl", 5)]
[[1, 12, 21, 31, 37, 46], [3, 8, 10, 30, 31, 49], [5, 12, 20, 22, 29, 40]]

Zugriff auf Listenelemente

Die Elemente einer Liste sind (in unserer Darstellung hier) alle durchnummeriert. Die Nummerierung beginnt dabei mit 0. Die Nummer eines Listenelements wird auch Index genannt.

Wir gehen (in unserer Darstellung hier) davon aus, dass ein lesender und schreibender Zugriff auf jedes Listenelement möglich ist. Wenn L eine Liste bezeichnet, dann beschreibt der Ausdruck L[i] das Listenelement mit der Nummer i.

>>> L = [10, 15, 21, 33, 37, 40]
>>> L[0]
10
>>> L[1]
15
>>> L
[10, 15, 21, 33, 37, 40]
>>> L[4] = 36
>>> L
[10, 15, 21, 33, 36, 40]

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

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']

Länge einer Liste

Da Listen dynamisch wachsen oder schrumpfen können, benötigt man häufig eine Operation zur Bestimmung der Länge der Liste. Die Länge einer Liste beschreibt dabei die Anzahl der Listenelemente. Wenn L eine Liste bezeichnet, dann beschreibt der Ausdruck len(L) die Länge der Liste.

>>> L = ['g', 't', 'e', 'c', 's', 'k', 'p']
>>> len(L)
7
>>> len([])
0
>>> len([1, [2, 3]])
2