Tuples

Material

Woche 2

Zuletzt aktualisiert

9. Oktober 2025

Der zweite Typ von Sammlungen in Python sind Tuples. Tuples sind Listen sehr ähnlich: Sie sind nicht homogen, Verschachtelungen sind möglich, sie sind geordnet und können Duplikate enthalten. Tuples unterscheiden sich aber auch von Listen: Sie sind immutable und werden mit runden Klammern () erstellt.

’

Eigenschaft	Liste	Tuple	Set	Dictionary
Darstellung	[ ]	( )	{ }	{ }
Beispiel	[1, 2, 2, 'drei']	(1, 2, 2, 'drei')	{'drei', 1, 2}	{1: 'a', 2: 'b', 3: 'b', 'drei': 'c'}
Homogenität	Nicht-homogen	Nicht-homogen	Nicht-homogen	Nicht-homogen
Verschachtelung möglich	Ja	Ja	Ja	Ja
Geordnet	Ja	Ja	Nein	Ja (Python 3.7+)
Duplikate erlaubt	Ja	Ja	Nein	Nein (nur Werte)
Mutability	{{< fa chalkboard >}} Mutable	{{< fa print >}} Immutable	{{< fa chalkboard >}} Mutable	{{< fa chalkboard >}} Mutable
Erstellung aus x	list(x)	tuple(x)	set(x)	dict(x)
Erstellung leer	[]	()	set()	{}

’

Arbeiten mit Tuples

Tuples können prinzipiell auf die gleiche Weise wie Listen erstellt und via indices behandelt werden. Ebenso können bestimmte Funktionen wie len() und sum() genutzt werden.

mein_tuple = ('Etwas', 42, 'Text', 42, 12.6, True)
mein_tuple

('Etwas', 42, 'Text', 42, 12.6, True)

zahlen_tuple = (1, 6, 3, 2)
sum(zahlen_tuple[2:])

Listen können auch in Tuples umgewandelt werden und umgekehrt. Dabei wird die ursprüngliche Sammlung nicht verändert, sondern eine neue Sammlung erstellt.

x = [1, 2, 3]
y = tuple(x)
print(x)

[1, 2, 3]

print(y)

(1, 2, 3)

x = (1, 2, 3)
y = list(x)
print(x)

(1, 2, 3)

print(y)

[1, 2, 3]

Immutable

Der markante Unterschied zu Listen ist, dass Tuples immutable sind. Demzufolge haben Tuples auch keine Methoden wie append(), remove(), del() oder pop(), da diese Methoden die Sammlung verändern würden.

# Füge ein Element hinzu
x = (1, 2, 3)
x.append(4)

Error: 'tuple' object has no attribute 'append'

# Lösche das erste Element
x = (1, 2, 3)
del(x[0])

Error: 'tuple' object doesn't support item deletion

Wenn man aber doch einen Tuple um Werte erweitern möchte oder bestimmte Werte löschen möchte, kann man das tun, indem man eine veränderte Kopie des Tuples erstellt. Man kann dann auch die alte Version mit der neuen überschreiben. Der + Operator funktioniert in diesem Fall genauso wie bei Listen und mittels Indizierung kann auch ein Slice des Tuples erstellt werden.

# Füge ein Element hinzu
x = (1, 2, 3)
x = x + (4,)
x

(1, 2, 3, 4)

# Lösche das erste Element
x = (1, 2, 3)
x = x[1:]
x

(2, 3)

Hinweis

Um einen Tupel mit nur einem Element zu erstellen, muss ein Komma hinter dem Element stehen. Andernfalls wird das Element als normaler Wert - also nicht als Tupel - interpretiert. Deshalb steht im Code oben (4,) anstatt (4). Um es noch verwirrender zu machen: In diesem Fall würde sogar 4,, also ohne Klammern, ausreichen. Meines Erachtens ist das aber nicht so intuitiv und sollte deshalb vermieden werden.

Vorteil zu Listen

Ein Vorteil von Tuples gegenüber Listen ist, dass sie weniger Speicherplatz einnehmen und schneller erzeugbar sind. Grund dafür ist eben, dass sie immutable sind. Hier zum Beweis ein kleiner Performance-Test: Mittels der Funktion timeit() aus dem gleichnamigen Modul wird die Zeit in Sekunden gemessen, die benötigt wird, um 10.000.000 Mal eine Liste bzw. ein Tuple zu erstellen.

import timeit

timeit.timeit(
  stmt = 'x = [1, "two", True]', 
  number = 10000000
)

0.46097069999996165

#

timeit.timeit(
  stmt = 'x = (1, "two", True)', 
  number = 10000000
)

0.12645290000000386

Weitere Ressourcen

Übungen

Tuples sind

MutableImmutable

Öffne dein Jupyter Notebook aus den Übungen im letzten Kapitel zu den Listen und speichere es als Kopie des ursprünglichen ab. Erzeuge in dieser zweiten Version neben den Listen ‘a’, ‘b’ und ‘c’ auch Tuple ‘x’, ‘y’ und ‘z’ mit gleichem Inhalt. Versuche dann die gleichen Operationen auf den Tuples durchzuführen, die du auf den Listen durchgeführt hast. Wie oben erklärt, wird dies in einigen Fällen nicht direkt möglich sein, da gewisse Funktionen nicht zur Verfügung stehen. Versuche aber trotzdem - mithilfe von entsprechenden alternativen Vorgehensweisen - die gleichen Ergebnisse zu erzielen. Strukturiere das Jupyter Notebook mithilfe von Überschriften und kurzen Erläuterungen so, dass es für jeden Schritt eine Gegenüberstellung der Vorgehensweisen zwischen Listen und Tuple gibt. Ziel ist es, dass du dieses Dokument später als Referenz nutzen kannst, falls du dich mal nicht mehr an die Unterschiede erinnern solltest.

Geschafft

--- title: Tuples author: "Woche 2" --- Der zweite Typ von Sammlungen in Python sind Tuples. Tuples sind Listen sehr ähnlich: Sie sind nicht homogen, Verschachtelungen sind möglich, sie sind geordnet und können Duplikate enthalten. Tuples unterscheiden sich aber auch von Listen: Sie sind immutable und werden mit runden Klammern `()` erstellt. ```{python} #| echo: false from utils import * ``` ::: {.content-visible when-format="html"} ```{python} #| echo: false #| results: asis datstr.to_html(index=False) ``` ::: ::: {.content-visible when-format="pdf"} ```{python} #| echo: false #| results: asis datstr ``` ::: # Arbeiten mit Tuples Tuples können prinzipiell auf die gleiche Weise wie Listen erstellt und via indices behandelt werden. Ebenso können bestimmte Funktionen wie `len()` und `sum()` genutzt werden. :::: {.grid} ::: {.g-col-6} ```{python} mein_tuple = ('Etwas', 42, 'Text', 42, 12.6, True) mein_tuple ``` ::: ::: {.g-col-6} ```{python} zahlen_tuple = (1, 6, 3, 2) sum(zahlen_tuple[2:]) ``` ::: :::: Listen können auch in Tuples umgewandelt werden und umgekehrt. Dabei wird die ursprüngliche Sammlung nicht verändert, sondern eine neue Sammlung erstellt. :::: {.grid} ::: {.g-col-6} ```{python} x = [1, 2, 3] y = tuple(x) print(x) print(y) ``` ::: ::: {.g-col-6} ```{python} x = (1, 2, 3) y = list(x) print(x) print(y) ``` ::: :::: ## Immutable Der markante Unterschied zu Listen ist, dass Tuples {{< fa print >}} immutable sind. Demzufolge haben Tuples auch keine Methoden wie `append()`, `remove()`, `del()` oder `pop()`, da diese Methoden die Sammlung verändern würden. :::: {.grid} ::: {.g-col-6} ```{python} #| eval: False # Füge ein Element hinzu x = (1, 2, 3) x.append(4) ``` ```{python} #| echo: False x = (1, 2, 3) try: x.append(4) except AttributeError as e: print(f"Error: {e}") ``` ::: ::: {.g-col-6} ```{python} #| eval: False # Lösche das erste Element x = (1, 2, 3) del(x[0]) ``` ```{python} #| echo: False x = (1, 2, 3) try: del(x[0]) except TypeError as e: # Adjusted to catch the correct exception type print(f"Error: {e}") ``` ::: :::: Wenn man aber doch einen Tuple um Werte erweitern möchte oder bestimmte Werte löschen möchte, kann man das tun, indem man eine veränderte Kopie des Tuples erstellt. Man kann dann auch die alte Version mit der neuen überschreiben. Der `+` Operator funktioniert in diesem Fall genauso wie bei Listen und mittels Indizierung kann auch ein Slice des Tuples erstellt werden. :::: {.grid} ::: {.g-col-6} ```{python} # Füge ein Element hinzu x = (1, 2, 3) x = x + (4,) x ``` ::: ::: {.g-col-6} ```{python} # Lösche das erste Element x = (1, 2, 3) x = x[1:] x ``` ::: :::: ::: callout-note Um einen Tupel mit nur einem Element zu erstellen, muss ein Komma hinter dem Element stehen. Andernfalls wird das Element als normaler Wert - also nicht als Tupel - interpretiert. Deshalb steht im Code oben `(4,)` anstatt `(4)`. Um es noch verwirrender zu machen: In diesem Fall würde sogar `4,`, also ohne Klammern, ausreichen. Meines Erachtens ist das aber nicht so intuitiv und sollte deshalb vermieden werden. ::: # Vorteil zu Listen Ein Vorteil von Tuples gegenüber Listen ist, dass sie weniger Speicherplatz einnehmen und schneller erzeugbar sind. Grund dafür ist eben, dass sie immutable sind. Hier zum Beweis ein kleiner Performance-Test: Mittels der Funktion `timeit()` aus dem gleichnamigen Modul wird die Zeit in Sekunden gemessen, die benötigt wird, um 10.000.000 Mal eine Liste bzw. ein Tuple zu erstellen. :::: {.grid} ::: {.g-col-6} ```{python} import timeit timeit.timeit( stmt = 'x = [1, "two", True]', number = 10000000 ) ``` ::: ::: {.g-col-6} ```{python} # timeit.timeit( stmt = 'x = (1, "two", True)', number = 10000000 ) ``` ::: :::: ::: callout-tip ## Weitere Ressourcen - [{{< fa brands youtube >}} why are TUPLES even a thing?](https://youtu.be/fR_D_KIAYrE?si=xsgVC1jBoqgRCIAu) - [{{< fa brands youtube >}} Python Tutorial #21 (deutsch) - Tuple](https://youtu.be/sRQeACJYZXE?si=a7QPVvQpcHSmH22x) - [{{< fa brands python >}} 5.3. Tuples and Sequences](https://docs.python.org/3/tutorial/datastructures.html#tuples-and-sequences) ::: # Übungen ::: {.webex-check .webex-box} ```{r} #| echo: false #| results: asis q <- "Tuples sind" q_choices <- c("Mutable", answer="Immutable") cat(q,longmcq(q_choices)) q <- "Öffne dein Jupyter Notebook aus den Übungen im letzten Kapitel zu den Listen und speichere es als Kopie des ursprünglichen ab. Erzeuge in dieser zweiten Version neben den Listen 'a', 'b' und 'c' auch Tuple 'x', 'y' und 'z' mit gleichem Inhalt. Versuche dann die gleichen Operationen auf den Tuples durchzuführen, die du auf den Listen durchgeführt hast. Wie oben erklärt, wird dies in einigen Fällen nicht direkt möglich sein, da gewisse Funktionen nicht zur Verfügung stehen. Versuche aber trotzdem - mithilfe von entsprechenden alternativen Vorgehensweisen - die gleichen Ergebnisse zu erzielen. Strukturiere das Jupyter Notebook mithilfe von Überschriften und kurzen Erläuterungen so, dass es für jeden Schritt eine Gegenüberstellung der Vorgehensweisen zwischen Listen und Tuple gibt. Ziel ist es, dass du dieses Dokument später als Referenz nutzen kannst, falls du dich mal nicht mehr an die Unterschiede erinnern solltest." q_choices <- c(answer="Geschafft") cat(q,longmcq(q_choices)) ``` :::