Das Python Tuple – Die große Übersicht

In Python gibt es vier integrierte Sammlungen. List, Set, Tuple und das Dictionary. In diesem Artikel werden wir die dritte Sammlung, das Python Tuple, näher besprechen.

Was ist ein Python Tuple?

Ein Tuple ist eine geordnete, sequenzielle Sammlung. Es kann Daten aller Typen aufnehmen, die über einen Index erreichbar sind. Ein Tuple kann im Gegensatz zu einer Liste nicht geändert werden.

Sobald ein Element in das Tuple eingefügt wurde, kann es nicht mehr verändert oder gelöscht werden. Es bedeutet allerdings nicht, dass Änderungen unmöglich sind. Alle diese Eigenschaften werden wir in diesem Artikel näher kennen lernen.

Wie erstellt man ein Python Tuple?

Uns stehen drei Wege zur Verfügung um ein Tuple zu erstellen. Wir können es entweder über Klammern, den Konstruktor oder durch Tuplepacking erstellen.

Starten wir zuerst mit den Klammern.

tuple1 = ()

„tuple1“ hält kein einziges Element. Es ist ein leeres Tuple. Jetzt können wir das Tuple mit ein paar beispielhaften Werten füllen.

tuple1 = (1, 2, 3, 4, 5)

„tuple1“ hält nun fünf Elemente. Die einzelnen Elemente werden durch ein Komma getrennt.

Wie eingangs erwähnt, kann ein Tuple Elemente verschiedener Datentypen beinhalten.

tuple1 = (1, 2, 3, 4, 5, 'a', 'b', 'c', "abc", True)

Jetzt hält das Tuple verschiedene Datentypen.

Zudem kann ein Tuple auch andere Sammlungen beinhalten.

tuple1 = (1, 2, [1, 2, 3], 3)

Eine weitere Möglichkeit ist die Verwendung des Konstruktors.

tuple1 = tuple();

Jetzt haben wir erneut ein leeres Tuple. Wie bereits zuvor können wir die Elemente innerhalb runder Klammern übergeben.

tuple1 = tuple((1, 2, 3, 4, 5))

Die dritte Möglichkeit ist das Tuplepacking. In dem Fall können wir das Tuple ohne Klammern erstellen.

tuple1 = (1, 2, 3, 4, 5)
tuple2 = 1, 2, 3, 4, 5

Beide Tuple sind gleich. Dies nennt sich Tuplepacking. Jetzt können wir ein weiteres Konzept verwenden, dass wir Tupleunpacking nennen.

tuple2 = 1, 2, 3, 4, 5
a, b, c, d, e = tuple2

Die Werte sind nun a = 1, b = 2, c = 3, d = 4, und e = 5.

Wir müssen allerdings beachten, dass die linken Werte die gleiche Anzahl wie die Elemente des Tuples haben. Ist dies nicht der Fall, bekommen wir eine Fehlermeldung.

tuple2 = 1, 2, 3, 4, 5
a, b = tuple2

Die Anzahl der jeweiligen Elemente ist ungleich (2 zu 5).

Wir können außerdem Probleme beim Erstellen eines Tuples über die Runden Klammern bekommen.

tuple1 = ("Hello World!")
tuple2 = (1, 2, 3, 4, 5)
typeof(tuple1)
typeof(tuple2)

Beide Tuples wurden über die Klammern erstellt. Der Typ der beiden Objekte sollte also ein Tuple sein.

„tuple1“ ist allerdings ein String. Selbstverständlich ist das ein Problem. Dieses können wir umgehen, wenn wir stattdessen den Konstruktor nutzen.

tuple1 = tuple(("Hello World!"))
type(tuple1)

Der Datentyp ist jetzt das Tuple.

Das gleiche Problem tritt auch beim Packing auf. Wollen wir also lediglich ein einzelnes Element in das Python Tuple einfügen, sollten wir immer den Konstruktor verwenden.

Die einzelnen Elemente eines Python Tuples adressieren

Die Adressierung ist der üblichste Weg in Python. Tuples sind über einen Index adressierbar. Also können wir die eckigen Klammern verwenden, um ein oder auch gleich mehrere Elemente auszuwählen.

tuple1 = (1, 2, 3, 4, 5)
tuple1[0]

Der 0te Index ist das erste Element im Tuple.

Über eine höhere Zahl können wir auch die anderen Elemente adressieren.

tuple1 = (1, 2, 3, 4, 5)
tuple1[0]
tuple1[1]
tuple1[2]
tuple1[3]
tuple1[4]

Über denselben Weg können wir auch bestimmte Teilmengen des Tuples adressieren. Dafür müssen wir lediglich den Start- und Endpunkt der Adressierung angeben. Diese trennen wir dann mit einem Doppelpunkt.

tuple1 = (1, 2, 3, 4, 5)
tuple1[0:3]

Der Startpunkt liegt bei 0. Der Endpunkt muss immer um eine Stelle verringert werden.

Schauen wir uns dafür einige Beispiele an.

tuple1 = (1, 2, 3, 4, 5)
tuple1[1:3]
tuple1[2:4]
tuple1[0:4]

Wir können auch negative Werte verwenden, um das Tuple vom Ende an zu adressieren.

tuple1 = (1, 2, 3, 4, 5)
tuple1[-1]
tuple1[-2]

Der erste Aufruf wird das letzte Element adressieren. Der Aufruf mit -2 wird das vorletzte Element adressieren.

Über ein Python Tuple iterieren

Wir können mittels einer for-Schleife über das Tuple iterieren.

tuple1 = (1, 2, 3, 4, 5)
for ele in tuple1:
	print(ele)

Das ist der häufigste gewählte Weg, um über das Tuple zu iterieren.

Wir können auch einen Index verwenden, um zu iterieren.

tuple1 = (1, 2, 3, 4, 5)
for i in range(0,len(tuple1)):
	print(tuple1[i])

Die integrierte Funktion Python range wird für die Schleife verwendet. Die Zahl „i“ geht dabei bei 0 los und endet beim letzten Element des Tuple.

Elemente zu einem Tuple hinzufügen

Normalerweise können wir Tuples in Python nicht verändern. Wir können also keine neuen Elemente einfügen. Was wir hingegen sehr wohl tun können, ist ein neues Tuple zu erstellen und die Elemente des Alten inklusive der Neuen einzufügen. Dafür können wir den +-Operator verwenden.

tuple1 = (1, 2, 3 , 4, 5)
tuple2 = tuple1 + (6, 7)

Im obigen Quellcode werden zusätzlich zum ersten Tuple noch die Werte 6 und 7 mittels des +-Operators eingefügt.

Wir können mittels des +-Operators beliebig viele Tuple zusammenfügen.

So können wir auch Elemente an eine gewünschte Position einfügen.

tuple1 = (1, 2, 3 , 4, 5)
tuple2 = tuple1[0:2] + (100, 200) + tuple1[2:len(tuple1)]

Es werden zwei neue Elemente an der 2. Stelle eingefügt.

Ein weiterer Weg besteht in der Umwandlung in eine Liste. So können wir die Elemente einfach der Liste hinzufügen und dann die Liste zurück in ein Tuple wandeln.

tuple1 = (1, 2, 3 , 4, 5)
list1 = list(tuple1)
list1.append(6)
list1.append(7)
tuple1 = tuple(list1)

Zunächst wird das Tuple mittels der list()-Funktion in eine Liste umgewandelt. Da die List in Python normal veränderbar ist, können wir die append()-Funktion verwenden, um neue Elemente anzuhängen. Danach können wir mittels des Konstruktors die Liste zurück in ein Tuple umwandeln.

Einzelne Werte eines Tuples aktualisieren

Die Werte der Elemente können aufgrund der Eigenschaften des Tuples nicht aktualisiert werden. Wir werden einen Fehler erhalten, wenn wir dies versuchen sollten.

tuple1 = (1, 2, 3, 4, 5)
tuple[0] = 100

Über den Index können wir zwar den Wert erhalten, diesen allerdings nicht verändern.

Wir können aber erneut das Tuple in eine List umwandeln und dann den Wert verändern.

tuple1 = (1, 2, 3 , 4, 5)
list1 = list(tuple1)
list1[0] = 100
tuple1 = tuple(list1)

Weil die List veränderbar ist, können wir den Wert aktualisieren. Danach wandeln wir die List einfach zurück in ein Tuple.

Einzelne Werte eines Tuples entfernen

Elemente können nicht aus einem Tuple entfernt werden. Wir werden einen Fehler erhalten, wenn wir dies versuchen sollten.

tuple1 = (1, 2, 3, 4, 5)
del tuple1[0]

Die del()-Funktion sollte das erste Element des Tuples löschen.

Wir können zwar kein einzelnes Element löschen, können allerdings das ganze Tuple löschen.

Wenn wir ein einzelnes Element aus dem Tuple löschen möchten, müssen wir erneut in eine Liste umwandeln. Dann können wir die del()-Funktion nutzen.

tuple1 = (1, 2, 3 , 4, 5)
list1 = list(tuple1)
del list1[0]
tuple1 = tuple(list1)

Die del()-Funktion löscht das angegebene Element.

Prüfen, ob ein Wert im Tuple enthalten ist: der in-Operator

Den in-Operator können wir nutzen, um das Tuple auf ein bestimmtes Element hin zu testen. Es gibt an, ob sich das Element im Tuple befindet, oder nicht.

tuple1 = (1, 2, 3, 4, 5)
2 in tuple1
4 in tuple1
100 in tuple1
200 in tuple1

Der in-Operator gibt einen boolschen Wert zurück. Wenn das Element existiert, wird True zurückgegeben. Andernfalls wird False zurückgegeben.

9. Wichtige Tuple-Methoden

Da das Tuple unveränderbar ist, gibt es keine integrierten Methoden, um dieses zu verändern. Es gibt allerdings zwei integrierte Funktion für das Tuple in Python.

Index()

Die index()-Funktion gibt den Index des übergebenen Wertes zurück.

tuple1 = (1, 2, 3, 4, 5)
tuple1.index(2)
tuple1.index(5)

tuple1 = (1, 2, 3, 4, 5)
tuple1.index(100)

Wir werden einen Value-Fehler erhalten, da das Element nicht im Tuple enthalten ist.

Count()

Die count()-Funktion wird verwendet, um die Anzahl der Vorkommnisse des Elements im Tuple zu erhalten.

tuple1 = (1, 2, 3, 4, 5, 2, 3, 2, 3)
tuple1.count(2)
tuple1.count(3)

Es wird 0 zurückgegeben, wenn das Element nicht im Tuple enthalten ist.

tuple1 = (1, 2, 3 , 4, 5, 2, 3, 2, 3)
tuple1.count(100)

Zusammenfassung – Das Python Tuple

Wie wir gelernt haben, verhält sich das Tuple ähnlich zur List. Allerdings sind einige Einschränkungen vorhanden. Der größte Unterschied ist die fehlende Möglichkeit zur Änderung. Wir können also keine neuen Elemente hinzufügen, vorhandene aktualisieren oder löschen. Müssen wir diese Funktionen verwenden, ist ein Umweg über die List notwendig.

Wenn wir verschiedene Datentypen in einer Sammlung speichern wollen, sollten wir das Tuple verwenden. Sind alle Elemente vom selben Datentyp, sollten wir die List verwenden. Handelt es sich hingegen um eine nicht änderbare Sammlung, ist das Iterieren schneller und die Daten sind besser gegen Fremdzugriff gesichert.