In diesem Lab erlangen Sie ein umfassendes Verständnis von Tupeln (Tuples) in Python. Sie lernen, wie man Tupel erstellt, auf ihre Elemente mittels Indizierung und Slicing zugreift und ihre Unveränderlichkeit (immutable nature) erkunden. Sie werden auch üben, Tupel-Operatoren, das Entpacken (unpacking) und gängige eingebaute Funktionen zu verwenden, um effizient mit Tupel-Daten zu arbeiten.
In diesem Schritt lernen Sie, wie man Tupel erstellt und auf deren Elemente zugreift. Tupel sind geordnete, unveränderliche (immutable) Sammlungen von Elementen, was bedeutet, dass ihr Inhalt nach der Erstellung nicht geändert werden kann.
Suchen Sie zunächst den Dateiexplorer auf der linken Seite der WebIDE. Finden und öffnen Sie die Datei mit dem Namen tuple_basics.py. Wir werden unseren Code in dieser Datei schreiben.
Beginnen wir mit der Erstellung einiger verschiedener Arten von Tupeln. Fügen Sie den folgenden Code zu tuple_basics.py hinzu:
## Create an empty tuple
empty_tuple = ()
print("Empty tuple:", empty_tuple)
print("Type of empty_tuple:", type(empty_tuple))
## Create a tuple with a single element (note the trailing comma)
single_element_tuple = (50,)
print("\nSingle element tuple:", single_element_tuple)
print("Type of single_element_tuple:", type(single_element_tuple))
## Create a tuple with multiple elements
fruits = ("apple", "banana", "cherry")
print("\nFruits tuple:", fruits)
## Create a tuple from a list using the tuple() constructor
numbers_list = [1, 2, 3, 4]
numbers_tuple = tuple(numbers_list)
print("\nTuple from list:", numbers_tuple)Nachdem Sie den Code hinzugefügt haben, speichern Sie die Datei (Sie können die Tastenkombination Strg+S verwenden). Öffnen Sie dann das Terminal am unteren Rand der WebIDE und führen Sie das Skript mit dem folgenden Befehl aus:
python tuple_basics.pySie sollten die folgende Ausgabe sehen, die die Erstellung und die Typen Ihrer Tupel bestätigt:
Empty tuple: ()
Type of empty_tuple: <class 'tuple'>
Single element tuple: (50,)
Type of single_element_tuple: <class 'tuple'>
Fruits tuple: ('apple', 'banana', 'cherry')
Tuple from list: (1, 2, 3, 4)Lernen wir nun, wie man auf die Elemente innerhalb eines Tupels zugreift. Sie können die Indizierung (beginnend bei 0) verwenden, um ein einzelnes Element zu erhalten, und das Slicing, um eine Teilsequenz von Elementen zu erhalten.
Fügen Sie den folgenden Code am Ende Ihrer Datei tuple_basics.py hinzu:
## Define a sample tuple for accessing elements
my_tuple = ('p', 'y', 't', 'h', 'o', 'n')
print("\nOriginal tuple:", my_tuple)
## Access elements using indexing
print("First element (index 0):", my_tuple[0])
print("Last element (index -1):", my_tuple[-1])
## Access elements using slicing
print("Elements from index 1 to 3:", my_tuple[1:4])
print("Elements from index 2 to the end:", my_tuple[2:])
print("Reverse the tuple:", my_tuple[::-1])Speichern Sie die Datei erneut und führen Sie das Skript im Terminal aus:
python tuple_basics.pyDie vollständige Ausgabe enthält nun die Ergebnisse des Zugriffs auf die Tupel-Elemente:
Empty tuple: ()
Type of empty_tuple: <class 'tuple'>
Single element tuple: (50,)
Type of single_element_tuple: <class 'tuple'>
Fruits tuple: ('apple', 'banana', 'cherry')
Tuple from list: (1, 2, 3, 4)
Original tuple: ('p', 'y', 't', 'h', 'o', 'n')
First element (index 0): p
Last element (index -1): n
Elements from index 1 to 3: ('y', 't', 'h')
Elements from index 2 to the end: ('t', 'h', 'o', 'n')
Reverse the tuple: ('n', 'o', 'h', 't', 'y', 'p')Sie haben nun erfolgreich Tupel erstellt und auf deren Elemente zugegriffen.
Ein Schlüsselmerkmal von Tupeln ist ihre Unveränderlichkeit (immutability). Das bedeutet, dass die Inhalte eines Tupels nach seiner Erstellung weder geändert, hinzugefügt noch entfernt werden können. In diesem Schritt sehen Sie, was passiert, wenn Sie versuchen, ein Tupel zu ändern, und lernen den korrekten Weg, eine „Änderung“ zu erreichen, indem Sie ein neues Tupel erstellen.
Öffnen Sie die Datei tuple_modification.py im Dateiexplorer.
Zuerst versuchen wir, ein Element in einem Tupel direkt zu ändern. Fügen Sie den folgenden Code zu tuple_modification.py hinzu. Die Zeile, die die Änderung versucht, ist auskommentiert.
my_tuple = ('a', 'b', 'c', 'd', 'e')
print("Original tuple:", my_tuple)
## The following line will cause a TypeError because tuples are immutable.
## You can uncomment it to see the error for yourself.
## my_tuple[0] = 'f'Wenn Sie den Code mit der vorletzten Zeile auskommentiert ausführen würden, würde Python anhalten und einen TypeError: 'tuple' object does not support item assignment anzeigen.
Da wir ein Tupel nicht direkt ändern können, besteht die Lösung darin, ein neues Tupel mit den gewünschten Änderungen zu erstellen. Dies können wir durch Slicing und Konkatenation (+) erreichen.
Fügen Sie den folgenden Code am Ende von tuple_modification.py hinzu, um zu sehen, wie man ein Element „ersetzt“:
## "Modify" a tuple by creating a new one
## Concatenate a new single-element tuple ('f',) with a slice of the original tuple
modified_tuple = ('f',) + my_tuple[1:]
print("New 'modified' tuple:", modified_tuple)
print("Original tuple is unchanged:", my_tuple)Ebenso können Sie ein Element „löschen“, indem Sie ein neues Tupel erstellen, das dieses Element ausschließt. Fügen Sie diesen Code zu Ihrer Datei hinzu:
## "Delete" an element by creating a new tuple
## Concatenate the slice before the element with the slice after the element
tuple_after_deletion = my_tuple[:2] + my_tuple[3:] ## Excludes element at index 2 ('c')
print("\nNew tuple after 'deletion':", tuple_after_deletion)Speichern Sie die Datei und führen Sie sie im Terminal aus:
python tuple_modification.pyDie Ausgabe wird demonstrieren, dass wir neue Tupel erstellt haben, während das Original unberührt bleibt:
Original tuple: ('a', 'b', 'c', 'd', 'e')
New 'modified' tuple: ('f', 'b', 'c', 'd', 'e')
Original tuple is unchanged: ('a', 'b', 'c', 'd', 'e')
New tuple after 'deletion': ('a', 'b', 'd', 'e')Dieser Schritt hebt die Unveränderlichkeit von Tupeln und die Standardpraxis hervor, diese Einschränkung zu umgehen.
Python bietet mehrere nützliche Operatoren für die Arbeit mit Tupeln. Sie lernen auch das Tupel-Unpacking (Entpacken) kennen, eine leistungsstarke Funktion zur Zuweisung von Tupel-Elementen zu Variablen.
Öffnen Sie die Datei tuple_operators.py im Dateiexplorer.
Lassen Sie uns die Operatoren für Konkatenation (+), Wiederholung (*) und Mitgliedschaft (in) untersuchen. Fügen Sie den folgenden Code zu tuple_operators.py hinzu:
tuple1 = (1, 2, 3)
tuple2 = ('a', 'b', 'c')
## Concatenation (+)
concatenated_tuple = tuple1 + tuple2
print("Concatenated:", concatenated_tuple)
## Repetition (*)
repeated_tuple = tuple1 * 3
print("Repeated:", repeated_tuple)
## Membership (in)
is_present = 'b' in tuple2
print("\nIs 'b' in tuple2?", is_present)
is_absent = 5 in tuple1
print("Is 5 in tuple1?", is_absent)Speichern Sie die Datei und führen Sie sie im Terminal aus:
python tuple_operators.pySie sehen die Ergebnisse dieser Operationen:
Concatenated: (1, 2, 3, 'a', 'b', 'c')
Repeated: (1, 2, 3, 1, 2, 3, 1, 2, 3)
Is 'b' in tuple2? True
Is 5 in tuple1? FalseAls Nächstes untersuchen wir das Tupel-Unpacking. Dies ermöglicht es Ihnen, die Elemente eines Tupels in einer einzigen, gut lesbaren Zeile mehreren Variablen zuzuweisen. Die Anzahl der Variablen muss der Anzahl der Elemente im Tupel entsprechen.
Fügen Sie den folgenden Code am Ende von tuple_operators.py hinzu:
## Tuple unpacking
person_info = ("Alice", 30, "Engineer")
name, age, profession = person_info
print("\nOriginal info tuple:", person_info)
print("Unpacked Name:", name)
print("Unpacked Age:", age)
print("Unpacked Profession:", profession)Speichern Sie die Datei erneut und führen Sie das Skript aus:
python tuple_operators.pyDie Ausgabe enthält nun die entpackten Variablen:
Concatenated: (1, 2, 3, 'a', 'b', 'c')
Repeated: (1, 2, 3, 1, 2, 3, 1, 2, 3)
Is 'b' in tuple2? True
Is 5 in tuple1? False
Original info tuple: ('Alice', 30, 'Engineer')
Unpacked Name: Alice
Unpacked Age: 30
Unpacked Profession: EngineerDas Tupel-Unpacking ist besonders nützlich für Funktionen, die mehrere Werte zurückgeben, da diese oft als Tupel zurückgegeben werden.
In diesem letzten Schritt lernen Sie, gängige eingebaute Funktionen (built-in functions) und Methoden kennenzulernen, die auf Tupel angewendet werden können. Tupel verfügen über zwei primäre Methoden, count() und index(), und können mit vielen Funktionen für allgemeine Zwecke verwendet werden.
Öffnen Sie die Datei tuple_functions.py im Dateiexplorer.
Beginnen wir mit den Tupel-Methoden. count() gibt zurück, wie oft ein Element vorkommt, und index() gibt den Index des ersten Vorkommens eines Elements zurück.
Fügen Sie den folgenden Code zu tuple_functions.py hinzu:
my_tuple = (1, 5, 2, 8, 5, 3, 5, 9)
print("Tuple:", my_tuple)
## count() method
count_of_5 = my_tuple.count(5)
print("Count of 5:", count_of_5)
## index() method
index_of_8 = my_tuple.index(8)
print("Index of 8:", index_of_8)Nun verwenden wir einige eingebaute Funktionen, die bei Tupeln sehr nützlich sind, wie z. B. len(), max(), min(), sum() und sorted().
Fügen Sie den folgenden Code am Ende von tuple_functions.py hinzu:
number_tuple = (10, 5, 20, 15, 30, 5)
print("\nNumber tuple:", number_tuple)
## len() function
print("Length:", len(number_tuple))
## max() and min() functions
print("Maximum value:", max(number_tuple))
print("Minimum value:", min(number_tuple))
## sum() function (for numeric tuples)
print("Sum of elements:", sum(number_tuple))
## sorted() function (returns a new sorted list)
sorted_list = sorted(number_tuple)
print("Sorted list from tuple:", sorted_list)Beachten Sie, dass die Funktion sorted() eine neue Liste und kein Tupel zurückgibt. Wenn Sie ein sortiertes Tupel benötigen, können Sie das Ergebnis mithilfe von tuple(sorted_list) zurückkonvertieren.
Speichern Sie die Datei und führen Sie sie im Terminal aus:
python tuple_functions.pyIhre Ausgabe sollte wie folgt aussehen:
Tuple: (1, 5, 2, 8, 5, 3, 5, 9)
Count of 5: 3
Index of 8: 3
Number tuple: (10, 5, 20, 15, 30, 5)
Length: 6
Maximum value: 30
Minimum value: 5
Sum of elements: 85
Sorted list from tuple: [5, 5, 10, 15, 20, 30]Sie haben nun gelernt, wichtige Methoden und Funktionen zur Inspektion und Analyse von Tupeln zu verwenden.
In diesem Lab haben Sie eine solide Grundlage für die Verwendung von Python-Tupeln erworben. Sie haben gelernt, wie man Tupel auf verschiedene Arten erstellt und wie man über Indexierung und Slicing auf ihre Elemente zugreift. Sie haben das Kernkonzept der Unveränderlichkeit (Immutability) von Tupeln untersucht und geübt, neue Tupel zu erstellen, um „Änderungen“ durchzuführen. Außerdem haben Sie sich mit gängigen Tupel-Operatoren wie + und *, dem Komfort des Tupel-Unpackings sowie dem Nutzen eingebauter Methoden (count(), index()) und Funktionen (len(), max(), sorted()) für die Arbeit mit Tupeldaten vertraut gemacht.
