2.3 Liste
Tupel können nicht verändert werden. In der Programmierpraxis werden aber Datenstrukturen benötigt, auf die Operationen wie das Einfügen, Anhängen und Sortieren von Elementen anwendbar sind. Für die Datenstruktur Liste sind diese Operationen und noch andere Operationen definiert (siehe Tabelle 2.4 und Tabelle 2.5). Eine Liste ist eine geordnete Zusammenfassung von Elementen. Als Elemente sind Objekte von unterschiedlichem Typ erlaubt. »Geordnet« bedeutet, dass jedem Element der Liste ein Index zugeordnet wird. Über diesen Index kann mit dem []-Operator lesend und schreibend auf die Liste zugegriffen werden. Erzeugt wird eine Liste entweder mit der eingebauten Python-Funktion list() oder indem man die Listenelemente in eckige Klammern einschließt. Die einzelnen Listenelemente müssen durch Kommata getrennt werden. Der Index beginnt bei 0 und nicht bei 1.
Der erste Konsolendialog zeigt, wie eine leere Liste erzeugt und wie ein neues Element eingefügt werden kann:
L=list()
>>> type(L)
<class 'list'>
>>> L.append(23)
>>> L
[23]
Mit der Methode append() wird ein Element am Ende der Liste eingefügt.
Mit der Funktion range(anfangswert, endwert, schrittweite) können Sie Listen aus ganzen Zahlen erzeugen:
>>> L=list(range(2,10,2))
>>> L
[2, 4, 6, 8]
In dem nächsten Konsolendialog wird eine Liste aus Zahlen erzeugt, die Typen der Zahlen werden ermittelt, und es wird gezeigt, wie lesend auf die Elemente einer Liste zugegriffen werden kann:
>>> L=[4.7,3.1,8.5,6.3,9]
>>> type(L)
<class 'list'>
>>> type(L[0])
<class 'float'>
>>> type(L[4])
<class 'int'>
>>> L[0]
4.7
>>> L[2]
8.5
>>> L[-1]
9
>>> L[5]
Traceback (most recent call last):
File "<pyshell>", line 1, in <module>
IndexError: list index out of range
Bis auf das letzte Element handelt es sich bei den Elementen der Liste L um Gleitpunktzahlen vom Typ <class float>.
Die Liste L hat insgesamt fünf Einträge. Mit L[0] wird auf das erste Element und mit L[4] wird auf das letzte Element der Liste zugegriffen. Mit dem Index -1 kann ebenfalls auf das letzte Element einer Liste zugegriffen werden. Der Versuch, mit L[5] auf die Liste lesend zuzugreifen, löst eine Fehlermeldung aus.
Tabelle 2.3 veranschaulicht den Aufbau einer Liste durch ein Modell.
|
Index |
0 |
1 |
2 |
3 |
4 |
|
Element |
4.7 |
3.1 |
8.5 |
6.3 |
9 |
Tabelle 2.3 Modell für den Aufbau einer Liste
Auf Listen sind viele Operationen anwendbar. Tabelle 2.4 gibt eine Übersicht über die eingebauten Python-Funktionen für die Operationen auf Listen. Der Bezeichner L steht für ein Listenobjekt.
|
Beschreibung |
|
|---|---|
|
del L[start:ende] |
Entfernt die Elemente zwischen start und ende. |
|
len(L) |
Ermittelt die Anzahl der Elemente der Liste L. |
|
min(L) |
Ermittelt das kleinste Element der Liste L. |
|
max(L) |
Ermittelt das größte Element der Liste L. |
|
sorted(L) |
Sortiert die Liste. Die Anordnung der Elemente der ursprünglichen Liste ändert sich nicht. |
|
sum(L) |
Berechnet die Summe der Listenelemente. |
|
L3=zip(L1,L2) |
Verbindet die Listenelemente aus der Liste L1 und L2 paarweise zu Tupeln. |
Tabelle 2.4 Funktionen für die Operationen auf Listen
Neben den Funktionen gibt es noch Methoden für die Operationen auf Listen. Tabelle 2.5 gibt eine Übersicht über diese Methoden.
|
Methode |
Beschreibung |
|---|---|
|
L.append(e) |
Das Element e wird an das Ende der Liste L angehängt. |
|
L.clear() |
Löscht die Liste L. |
|
L.count(e) |
Ermittelt, wie oft das Element e in der Liste L enthalten ist. |
|
L1.extend(L2) |
Die Liste L2 wird an das Ende der Liste L1 angehängt. |
|
L.insert(i,e) |
Das Element e wird an der Stelle i eingefügt. |
|
L.pop(i) |
Liest das Element der Liste L an der Position i und entfernt es. |
|
L.remove(e) |
Das Element e wird aus der Liste L entfernt. |
|
L.reverse() |
Die Reihenfolge der Listenelemente wird umgekehrt. |
|
L.sort() |
Sortiert die Liste L. Verändert die Anordnung der Elemente der ursprünglichen Liste L. |
Tabelle 2.5 Methoden für die Operationen auf Listen
Der nachfolgende Konsolendialog zeigt die Anwendungen einiger Operationen auf Listen:
>>> L=[1,2,3,4,5]
>>> L.reverse()
>>> L
[5, 4, 3, 2, 1]
>>> L.sort()
>>> L
[1, 2, 3, 4, 5]
>>> L.append(3)
>>> L
[1, 2, 3, 4, 5, 3]
>>> L.count(3)
2
>>> L.insert(2,9)
>>> L
[1, 2, 9, 3, 4, 5, 3]
>>> L.remove(1)
>>> L
[2, 9, 3, 4, 5, 3]
Listing 2.4 zeigt, wie ausgewählte Operationen auf eine Liste mit ungeraden und geraden Zahlen angewandt werden können:
01 #04_liste1.py
02 U=[1,3,5,7,11,13,15]
03 G=[2,4,6,8,10,12,14]
04 R=list(reversed(G))
05 summe=sum(U)
06 UG = U + G
07 Z=list(zip(U,G))
08 print("U =",U)
09 print("G =",G)
10 print("G[2:5] =",G[2:5])
11 print("Reihenfolge von G umkehren\n",R)
12 print("Anzahl der Elemente von U: n =",len(U))
13 print("Summe von U =",summe)
14 print("Liste G an Liste U anfügen\n",UG)
15 print("Liste sortieren\n",sorted(UG))
16 print("Liste verketten\n",Z)
17 print(type(Z))
Listing 2.4 Operationen auf Listen
Ausgabe
U = [1, 3, 5, 7, 11, 13, 15]
G = [2, 4, 6, 8, 10, 12, 14]
G[2:5] = [6, 8, 10]
Reihenfolge von G umkehren
[14, 12, 10, 8, 6, 4, 2]
Anzahl der Elemente von U: n = 7
Summe von U = 55
Liste G an Liste U anfügen
[1, 3, 5, 7, 11, 13, 15, 2, 4, 6, 8, 10, 12, 14]
Liste sortieren
[1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 14, 15]
Liste verketten
[(1, 2), (3, 4), (5, 6), (7, 8), (11, 10), (13, 12), (15, 14)]
<class 'list'>
Analyse
In den Zeilen 02 und 03 werden die Listen U und G erzeugt.
In Zeile 04 bewirkt die eingebaute Python-Funktion reversed(G), dass die Reihenfolge von G umgekehrt wird. In Zeile 05 berechnet die eingebaute Python-Funktion sum(U) die Summe aus den Elementen der Liste U. In Zeile 06 wird die Liste G an die Liste U angehängt. In Zeile 07 verkettet die eingebaute Python-Funktion zip(U,G) die beiden Listen U und G. Die Listeneinträge bestehen jetzt aus Tupeln.
In Zeile 10 werden durch sogenanntes Slicing (dt. Herausschneiden) die Elemente mit dem Index 2 bis 5 ausgegeben.
Verschachtelte Listen
Mit Listen können auch n × m-Matrizen dargestellt werden. Die quadratische Matrix
soll als Python-Liste implementiert werden. Außerdem soll gezeigt werden, wie man auf einzelne Listenelemente zugreifen kann. Listing 2.5 zeigt die Umsetzung:
01 #05_liste2.py
02 a=[[3,2,1],
03 [4,5,6],
04 [9,8,7]]
05 print("3 x 3 Matrix")
06 print(a[0])
07 print(a[1])
08 print(a[2])
09 print("Elemente der Matrix")
10 print("a11 =",a[0][0])
11 print("a22 =",a[1][1])
12 print("a33 =",a[2][2])
13 print("a12 =",a[0][1])
14 print("a21 =",a[1][0])
Listing 2.5 Implementierung einer 3×3-Matrix mit Listen
Ausgabe
3 x 3 Matrix
[3, 2, 1]
[4, 5, 6]
[9, 8, 7]
Elemente der Matrix
a11 = 3
a22 = 5
a33 = 7
a12 = 2
a21 = 4
Analyse
In den Zeilen 02 bis 04 wird die quadratische Matrix a erzeugt. Jede Zeile der Matrix besteht aus einer Liste. Damit eine quadratische Liste erzeugt wird, müssen die drei Listen noch in zwei rechteckige Klammern eingeschlossen werden. Eine Matrix wird also als verschachtelte Liste definiert.
Die Matrix kann zeilenweise ausgegeben werden (Zeilen 06 bis 08). Der Index 0 steht für die erste Zeile, der Index 1 für die zweite Zeile usw.
Mit a[i][j] kann auf die einzelnen Elemente der Matrix zugegriffen werden (Zeilen 10 bis 14).