Einführung
Willkommen zu diesem praktischen Laborexperiment über Python-Listen (Lists) und Tupel (Tuples). Listen sind eine der fundamentalsten und vielseitigsten Datenstrukturen in Python, die es Ihnen ermöglichen, geordnete Sammlungen von Elementen zu speichern. Tupel sind ähnlich, weisen jedoch einen wesentlichen Unterschied auf: Sie sind unveränderlich (immutable).
Im Laufe dieses Labors lernen Sie, wie man Listen erstellt, auf ihre Elemente zugreift und diese manipuliert, sowie gängige Operationen wie Sortieren und Iterieren (Looping) durchführt. Sie werden auch Tupel erkunden und verstehen, wann man sie anstelle von Listen verwendet.
Diese Laborumgebung ist eine vorkonfigurierte WebIDE. Alle notwendigen Dateien für dieses Labor wurden für Sie im Verzeichnis /home/labex/project erstellt. Lassen Sie uns beginnen.
Zugriff auf Listenelemente
In diesem Schritt lernen Sie, wie Sie Elemente aus einer Liste mithilfe von Indizes abrufen und wie Sie Teillisten (Sublists) mithilfe von Slicing extrahieren. Listen sind geordnete Sammlungen von Elementen, die in eckigen Klammern [] eingeschlossen sind.
Öffnen Sie zunächst die Datei step1_access.py im Dateiexplorer auf der linken Seite. Wir werden unseren Code in dieser Datei schreiben.
Hinweis: Wenn Sie mit der Verwendung von WebIDE (ähnlich VS Code) nicht vertraut sind, lernen Sie dies zuerst in diesem Lab.
Werte mit Indizes abrufen
Auf Listenelemente wird mithilfe eines nullbasierten Index zugegriffen, was bedeutet, dass das erste Element den Index 0 hat.
Fügen Sie den folgenden Code zu step1_access.py hinzu, um eine Liste zu erstellen und auf ihr erstes Element zuzugreifen:
## step1_access.py
furniture = ['table', 'chair', 'rack', 'shelf']
## Zugriff auf das erste Element (Index 0)
print(furniture[0])
Um das Skript auszuführen, öffnen Sie ein Terminal in der WebIDE und führen Sie den folgenden Befehl aus:
python3 /home/labex/project/step1_access.py
Sie sollten sehen, wie das erste Element der Liste in der Konsole ausgegeben wird.
Ausgabe:
table
Negative Indizes
Sie können auch negative Indizes verwenden, um auf Elemente vom Ende der Liste zuzugreifen. Index -1 bezieht sich auf das letzte Element, -2 auf das vorletzte und so weiter.
Ändern Sie step1_access.py, um auf das letzte Element zuzugreifen:
## step1_access.py
furniture = ['table', 'chair', 'rack', 'shelf']
## Zugriff auf das letzte Element (Index -1)
print(furniture[-1])
Führen Sie das Skript erneut aus:
python3 /home/labex/project/step1_access.py
Ausgabe:
shelf
Teillisten mit Slices abrufen
Slicing ermöglicht es Ihnen, eine Teilliste mithilfe der Syntax [start:end] abzurufen. Der start-Index ist inklusiv, und der end-Index ist exklusiv.
Lassen Sie uns dies üben. Ersetzen Sie für Ihre Verifizierungsaufgabe den bestehenden Inhalt von step1_access.py durch den folgenden Code, um eine Liste zu erstellen und einen Slice davon auszugeben:
## step1_access.py
furniture = ['table', 'chair', 'rack', 'shelf']
## Eine Teilliste vom Index 1 bis (aber nicht einschließlich) Index 3 abrufen
sublist = furniture[1:3]
print(sublist)
Führen Sie das Skript aus, um das Ergebnis zu sehen:
python3 /home/labex/project/step1_access.py
Ausgabe:
['chair', 'rack']
Sie können auch eine Kopie einer Liste mithilfe eines vollständigen Slices [:] erstellen. Alle Änderungen an der ursprünglichen Liste wirken sich nicht auf die Kopie aus.
## step1_access.py
spam = ['cat', 'bat', 'rat', 'elephant']
spam2 = spam[:] ## Eine flache Kopie (shallow copy) erstellen
spam.append('dog')
print(spam)
print(spam2)
Führen Sie das Skript aus:
python3 /home/labex/project/step1_access.py
Ausgabe:
['cat', 'bat', 'rat', 'elephant', 'dog']
['cat', 'bat', 'rat', 'elephant']
Nachdem Sie erfolgreich den Slice ['chair', 'rack'] ausgegeben haben, klicken Sie auf die Schaltfläche Verify (Überprüfen), um mit dem nächsten Schritt fortzufahren.
Listen modifizieren und manipulieren
In diesem Schritt erkunden Sie, wie Sie Listeninhalte verwalten und ändern können. Dies umfasst das Ändern von Werten, das Kombinieren von Listen und das Hinzufügen neuer Elemente.
Öffnen Sie die Datei step2_modify.py, um zu beginnen.
Abrufen der Listenlänge mit len()
Die Funktion len() gibt die Anzahl der Elemente in einer Liste zurück.
Fügen Sie diesen Code zu step2_modify.py hinzu:
## step2_modify.py
furniture = ['table', 'chair', 'rack', 'shelf']
print(len(furniture))
Führen Sie das Skript aus:
python3 /home/labex/project/step2_modify.py
Ausgabe:
4
Ändern von Werten mit Indizes
Sie können ein Element in einer Liste ändern, indem Sie ihm einen neuen Wert über seinen Index zuweisen.
## step2_modify.py
furniture = ['table', 'chair', 'rack', 'shelf']
furniture[0] = 'desk' ## Das erste Element ändern
print(furniture)
Führen Sie das Skript aus:
python3 /home/labex/project/step2_modify.py
Ausgabe:
['desk', 'chair', 'rack', 'shelf']
Konkatenation und Replikation
Sie können zwei Listen mithilfe des +-Operators (Konkatenation) kombinieren oder den Inhalt einer Liste mithilfe des *-Operators (Replikation) wiederholen.
## step2_modify.py
list1 = [1, 2, 3]
list2 = ['A', 'B', 'C']
combined_list = list1 + list2
print(combined_list)
replicated_list = ['X'] * 3
print(replicated_list)
Führen Sie das Skript aus:
python3 /home/labex/project/step2_modify.py
Ausgabe:
[1, 2, 3, 'A', 'B', 'C']
['X', 'X', 'X']
Hinzufügen von Werten mit append() und insert()
- Die Methode
append()fügt ein Element am Ende der Liste hinzu. - Die Methode
insert()fügt ein Element an einem angegebenen Index hinzu.
Ersetzen Sie für Ihre Verifizierungsaufgabe den Inhalt von step2_modify.py durch den folgenden Code, der diese Operationen kombiniert. Dieses Skript erstellt eine Liste, fügt ein Element am Ende hinzu und fügt ein weiteres am Anfang ein.
## step2_modify.py
furniture = ['table', 'chair', 'rack', 'shelf']
## 'bed' am Ende der Liste hinzufügen
furniture.append('bed')
## 'desk' am Anfang der Liste einfügen (Index 0)
furniture.insert(0, 'desk')
print(furniture)
Führen Sie das Skript aus, um die endgültig modifizierte Liste anzuzeigen:
python3 /home/labex/project/step2_modify.py
Ausgabe:
['desk', 'table', 'chair', 'rack', 'shelf', 'bed']
Sobald Ihr Skript die korrekte Ausgabe liefert, klicken Sie auf Verify.
Werte entfernen und sortieren
In diesem Schritt lernen Sie verschiedene Möglichkeiten kennen, Elemente aus einer Liste zu entfernen, und wie Sie den Inhalt einer Liste sortieren können.
Öffnen Sie bitte die Datei step3_remove.py.
Entfernen von Werten
Python bietet mehrere Möglichkeiten, Elemente aus einer Liste zu entfernen:
del-Anweisung: Entfernt ein Element an einem bestimmten Index.remove()-Methode: Entfernt das erste Vorkommen eines bestimmten Wertes.pop()-Methode: Entfernt und gibt ein Element an einem bestimmten Index zurück (oder das letzte Element, wenn kein Index angegeben wird).
Sehen wir uns diese in Aktion an. Fügen Sie dies zu step3_remove.py hinzu:
## step3_remove.py
furniture = ['table', 'chair', 'rack', 'shelf']
del furniture[2] ## Entfernt 'rack'
print(furniture)
furniture.remove('chair') ## Entfernt 'chair'
print(furniture)
Führen Sie das Skript aus:
python3 /home/labex/project/step3_remove.py
Ausgabe:
['table', 'chair', 'shelf']
['table', 'shelf']
Sortieren von Werten mit sort()
Die Methode sort() sortiert die Liste "in place" (direkt in der Liste). Standardmäßig erfolgt die Sortierung in aufsteigender Reihenfolge.
## step3_remove.py
numbers = [2, 5, 3.14, 1, -7]
numbers.sort()
print(numbers)
letters = ['a', 'z', 'A', 'Z']
letters.sort(key=str.lower) ## Sortierung ohne Berücksichtigung der Groß-/Kleinschreibung (case-insensitive)
print(letters)
Führen Sie das Skript aus:
python3 /home/labex/project/step3_remove.py
Ausgabe:
[-7, 1, 2, 3.14, 5]
['a', 'A', 'z', 'Z']
Für Ihre Verifizierungsaufgabe müssen Sie eine Liste erstellen, ein bestimmtes Element entfernen und dann die verbleibenden Elemente sortieren. Ersetzen Sie den Inhalt von step3_remove.py durch Folgendes:
## step3_remove.py
furniture = ['table', 'chair', 'rack', 'shelf']
## Das Element 'rack' entfernen
furniture.remove('rack')
## Die Liste alphabetisch sortieren
furniture.sort()
print(furniture)
Führen Sie das Skript aus, um das Ergebnis zu sehen:
python3 /home/labex/project/step3_remove.py
Ausgabe:
['chair', 'shelf', 'table']
Nachdem Ihr Skript die Liste korrekt entfernt und sortiert hat, klicken Sie auf Verify.
Schleifen und fortgeschrittene Techniken
In diesem Schritt lernen Sie, wie Sie Listen durchlaufen (iterieren) und einige fortgeschrittene, aber sehr nützliche Listentechniken anwenden.
Öffnen Sie für diesen Abschnitt die Datei step4_loop.py.
Durchlaufen mit for
Eine for-Schleife ist die Standardmethode, um über die Elemente einer Liste zu iterieren.
## step4_loop.py
furniture = ['table', 'chair', 'rack', 'shelf']
for item in furniture:
print(item)
Führen Sie das Skript aus:
python3 /home/labex/project/step4_loop.py
Ausgabe:
table
chair
rack
shelf
Abrufen von Index und Wert mit enumerate()
Wenn Sie während der Iteration sowohl den Index als auch den Wert benötigen, verwenden Sie die Funktion enumerate().
## step4_loop.py
furniture = ['table', 'chair', 'rack', 'shelf']
for index, item in enumerate(furniture):
print(f'index: {index} - item: {item}')
Führen Sie das Skript aus:
python3 /home/labex/project/step4_loop.py
Ausgabe:
index: 0 - item: table
index: 1 - item: chair
index: 2 - item: rack
index: 3 - item: shelf
Die Operatoren in und not in
Diese Operatoren ermöglichen es Ihnen zu überprüfen, ob ein Wert in einer Liste vorhanden ist.
## step4_loop.py
furniture = ['table', 'chair', 'rack', 'shelf']
print('rack' in furniture)
print('bed' not in furniture)
Führen Sie das Skript aus:
python3 /home/labex/project/step4_loop.py
Ausgabe:
True
True
Durchlaufen mehrerer Listen mit zip()
Die Funktion zip() eignet sich hervorragend für die parallele Verarbeitung mehrerer Listen. Sie kombiniert Elemente aus jeder Liste paarweise.
Für Ihre Verifizierungsaufgabe werden Sie zip() verwenden, um zwei Listen zu kombinieren. Ersetzen Sie den Inhalt von step4_loop.py durch den folgenden Code. Er iteriert über die Möbelstücke und deren entsprechende Preise und gibt für jedes Paar eine formatierte Zeichenkette aus.
## step4_loop.py
furniture = ['table', 'chair', 'rack', 'shelf']
price = [100, 50, 80, 40]
for item, amount in zip(furniture, price):
print(f'The {item} costs ${amount}')
Führen Sie das Skript aus, um die kombinierte Ausgabe zu sehen:
python3 /home/labex/project/step4_loop.py
Ausgabe:
The table costs $100
The chair costs $50
The rack costs $80
The shelf costs $40
Sobald Ihr Skript korrekt funktioniert, klicken Sie auf Verify.
Tupel verstehen
In diesem letzten Schritt lernen Sie den Datentyp Tupel (Tuple) kennen. Tupel ähneln Listen, sind jedoch unveränderlich (immutable), was bedeutet, dass ihr Inhalt nach der Erstellung nicht mehr geändert werden kann.
Öffnen Sie für diesen Abschnitt die Datei step5_tuple.py.
Der Tupel-Datentyp
Tupel werden mit runden Klammern () anstelle von eckigen Klammern definiert. Da sie unveränderlich sind, können Sie nach der Erstellung des Tupels keine Elemente ändern, hinzufügen oder entfernen. Dies macht sie speichereffizienter und nützlich für Daten, die unverändert bleiben sollen.
Sie können auf Tupel-Elemente mithilfe von Indizes und Slicing zugreifen, genau wie bei Listen.
## step5_tuple.py
furniture = ('table', 'chair', 'rack', 'shelf')
## Zugriff auf Elemente
print(furniture[0])
## Slicing
print(furniture[1:3])
## Länge ermitteln
print(len(furniture))
Führen Sie das Skript aus:
python3 /home/labex/project/step5_tuple.py
Ausgabe:
table
('chair', 'rack')
4
Wenn Sie versuchen, ein Tupel zu ändern, löst Python einen TypeError aus. Zum Beispiel würde furniture[0] = 'desk' einen Fehler verursachen.
Konvertierung zwischen list() und tuple()
Sie können mithilfe der Konstruktorfunktionen list() und tuple() einfach zwischen Listen und Tupeln konvertieren.
Für Ihre Verifizierungsaufgabe werden Sie eine Liste in ein Tupel konvertieren. Ersetzen Sie den Inhalt von step5_tuple.py durch den folgenden Code:
## step5_tuple.py
## Eine Liste von Elementen
my_list = ['cat', 'dog', 5]
## Die Liste in ein Tupel konvertieren
my_tuple = tuple(my_list)
print(my_tuple)
Führen Sie das Skript aus, um das resultierende Tupel anzuzeigen:
python3 /home/labex/project/step5_tuple.py
Ausgabe:
('cat', 'dog', 5)
Sie können ein Tupel auch wieder in eine Liste umwandeln, falls Sie es ändern müssen:
## step5_tuple.py
my_tuple = ('cat', 'dog', 5)
my_list = list(my_tuple)
print(my_list)
Führen Sie das Skript aus:
python3 /home/labex/project/step5_tuple.py
Ausgabe:
['cat', 'dog', 5]
Sobald Ihr Skript die Liste erfolgreich in ein Tupel konvertiert und dieses ausgegeben hat, klicken Sie auf Verify, um das Lab abzuschließen.
Zusammenfassung
Herzlichen Glückwunsch zum Abschluss des Labs! Sie haben ein solides Verständnis der Kern-Datenstrukturen von Python erlangt: Listen und Tupel.
Sie haben gelernt, wie man:
- Listen erstellt und Elemente mithilfe positiver und negativer Indizes zugreift.
- Teillisten mithilfe von Slicing extrahiert.
- Listen modifiziert, indem Werte geändert, Elemente mit
append()undinsert()hinzugefügt und mitdel,remove()undpop()entfernt werden. - Listen "in-place" mithilfe der Methode
sort()sortiert. - Listen effektiv mithilfe von
for-Schleifen,enumerate()undzip()durchläuft. - Die Unveränderlichkeit (Immutability) von Tupeln versteht und zwischen Listen und Tupeln konvertiert.
Diese Fähigkeiten sind grundlegend für jeden Python-Programmierer und werden in Ihren zukünftigen Projekten von unschätzbarem Wert sein.
