Python Tuples: Ein vollständiger Leitfaden

Ein Tuple ist eine geordnete, unveränderliche Sequenz in Python. Es kann Elemente beliebigen Typs enthalten — Ganzzahlen, Strings, Gleitkommazahlen, andere Tuples — und diese Elemente behalten ihre Position dauerhaft, nachdem das Tuple erstellt wurde. Diese Seite behandelt alles, was Sie für die Arbeit mit Tuples benötigen: wie man sie erstellt, ausliest, kombiniert und wann man sie einer Python-Liste vorzieht.

Was ist ein Python Tuple?

Ein Tuple wird als kommagetrennte Sequenz in runden Klammern geschrieben:

Drei wesentliche Eigenschaften definieren Tuples:

• Geordnet — Elemente haben eine feste Position (Index 0, 1, 2, …).
• Unveränderlich — nach der Erstellung können keine Elemente geändert, hinzugefügt oder entfernt werden.
• Erlaubt Duplikate — derselbe Wert kann mehrfach vorkommen.

Tuples vs. Listen

Sowohl Tuples als auch Listen speichern geordnete Sequenzen, unterscheiden sich aber grundlegend in ihrer Veränderlichkeit:

Verwenden Sie ein Tuple, wenn sich die Daten nicht ändern sollen — Konfigurationskonstanten, Rückgabewerte von Funktionen, die mehrere zusammengehörige Daten tragen, oder Dictionary-Schlüssel.

Tuples erstellen

Grundlegende Syntax

Kommagetrennte Werte in runden Klammern aufführen:

Gemischte Typen

Ein Tuple kann Elemente verschiedener Typen enthalten, einschließlich anderer Tuples:

mixed = (1, 'hello', 3.14, True)
print(mixed)
# Output: (1, 'hello', 3.14, True)

Leeres Tuple

empty = ()
print(empty)        # Output: ()
print(type(empty))  # Output: <class 'tuple'>

Einelementiges Tuple

Dies ist eine häufige Fehlerquelle. Ohne das abschließende Komma behandelt Python die Klammern als Gruppierung, nicht als Tuple:

not_a_tuple = (42)
print(type(not_a_tuple))  # Output: <class 'int'>

real_tuple = (42,)
print(type(real_tuple))   # Output: <class 'tuple'>

Das abschließende Komma macht es zu einem Tuple — fügen Sie es bei einelementigen Tuples immer ein.

Aus einem Iterable erstellen

Verwenden Sie den eingebauten tuple()-Konstruktor, um ein beliebiges Iterable in ein Tuple umzuwandeln:

Tuple ohne Klammern (Packing)

Python erlaubt es, ein Tuple zu erstellen, indem man einfach durch Kommas getrennte Werte auflistet — die Klammern sind optional:

packed = 1, 2, 3
print(packed)        # Output: (1, 2, 3)
print(type(packed))  # Output: <class 'tuple'>

Auf Tuple-Elemente zugreifen

Positiver Index

Indizes beginnen bei 0 für das erste Element:

Negativer Index

Negative Indizes zählen vom Ende. -1 ist das letzte Element:

Slicing

Verwenden Sie [start:stop:step], um ein Teil-Tuple zu extrahieren. Der stop-Index ist ausgeschlossen:

t = (0, 1, 2, 3, 4)
print(t[1:4])   # Output: (1, 2, 3)
print(t[:3])    # Output: (0, 1, 2)
print(t[2:])    # Output: (2, 3, 4)
print(t[::2])   # Output: (0, 2, 4)

Verschachtelte Tuples

Greifen Sie auf verschachtelte Elemente zu, indem Sie Index-Klammern verketten:

nested = ((1, 2), (3, 4), (5, 6))
print(nested[1])     # Output: (3, 4)
print(nested[1][0])  # Output: 3

Zugehörigkeit prüfen

Der in-Operator prüft, ob ein Wert in einem Tuple vorhanden ist:

fruits = ('apple', 'banana', 'cherry')
print('banana' in fruits)  # Output: True
print('mango' in fruits)   # Output: False

Weitere Indizierungs- und Slicing-Techniken finden Sie unter Access Tuples.

Unveränderlichkeit von Tuples

Einmal erstellt, können die Elemente eines Tuples nicht mehr geändert werden:

my_tuple = (1, 2, 3)
my_tuple[0] = 99  # TypeError: 'tuple' object does not support item assignment

Wenn Sie eine geänderte Version benötigen, erstellen Sie ein neues Tuple aus Slices und Verkettung:

Beachten Sie, dass ein Tuple veränderliche Objekte wie Listen enthalten kann. Das Tuple selbst ist unveränderlich (Sie können den Listen-Verweis nicht austauschen), aber die Liste darin kann weiterhin geändert werden.

Eine vollständige Besprechung von Workarounds finden Sie unter Update Tuples.

Tuple-Operationen

Verkettung mit +

Zwei Tuples mit + zu verbinden, erstellt ein neues Tuple:

t1 = (1, 2)
t2 = (3, 4)
print(t1 + t2)
# Output: (1, 2, 3, 4)

Wiederholung mit *

Den Inhalt eines Tuples mit * wiederholen:

t = (0,) * 3
print(t)
# Output: (0, 0, 0)

Alle Verbindungsstrategien finden Sie unter Join Tuples.

Tuple-Methoden

Tuples haben genau zwei eingebaute Methoden, da die Unveränderlichkeit alles ausschließt, was die Sammlung modifizieren würde.

count()

Gibt zurück, wie oft ein Wert vorkommt:

index()

Gibt den Index des ersten Vorkommens eines Wertes zurück. Wirft ValueError, wenn der Wert nicht gefunden wird:

Eine vollständige Referenz finden Sie unter Tuple Methods.

Eingebaute Funktionen mit Tuples

Pythons eingebaute Funktionen arbeiten mit jedem Iterable, einschließlich Tuples:

sorted() gibt immer eine Liste zurück, auch wenn ein Tuple als Eingabe übergeben wird. Verwenden Sie tuple(), wenn Sie ein sortiertes Tuple zurückbenötigen.

Tuple Unpacking

Unpacking weist jedes Element eines Tuples in einer einzigen Anweisung einer separaten Variable zu:

Erweitertes Unpacking mit *

Eine mit Stern versehene Variable nimmt eine beliebige Anzahl verbleibender Elemente als Liste auf:

first, *rest = (10, 20, 30, 40)
print(first)  # Output: 10
print(rest)   # Output: [20, 30, 40]

Variablen tauschen

Tuple Unpacking macht den Variablentausch zu einer einzeiligen Operation — keine temporäre Variable nötig:

x, y = 5, 10
x, y = y, x
print(x, y)
# Output: 10 5

Weitere Muster einschließlich verschachteltem Unpacking finden Sie unter Unpack Tuples.

Über ein Tuple iterieren

Eine for-Schleife besucht jedes Element in der Reihenfolge:

fruits = ('apple', 'banana', 'cherry')
for fruit in fruits:
    print(fruit)
# Output:
# apple
# banana
# cherry

Verwenden Sie enumerate(), wenn Sie auch den Index benötigen:

for i, fruit in enumerate(fruits):
    print(i, fruit)
# Output:
# 0 apple
# 1 banana
# 2 cherry

while-Schleifen, zip() und die Traversierung verschachtelter Tuples finden Sie unter Loop Tuples.

Tuples aus Comprehensions erstellen

Python hat keine Tuple-Comprehension-Syntax, aber Sie können einen Generatorausdruck an tuple() übergeben, um dasselbe Ergebnis zu erzielen:

Der Ausdruck x**2 for x in my_list innerhalb von tuple() ist ein Generator — er erzeugt Werte einzeln, ohne eine Zwischenliste aufzubauen.

Wann sollte man Tuples verwenden?

Tuples glänzen in bestimmten Situationen:

• Mehrere Rückgabewerte. Funktionen können mehrere Werte sauber als Tuple zurückgeben: return x, y.
• Dictionary-Schlüssel. Listen können keine Dictionary-Schlüssel sein, weil sie veränderlich sind; Tuples hingegen schon.
• Datenintegrität. Wenn sich eine Sammlung nicht ändern soll — RGB-Werte, Datenbankzeilen, geografische Koordinaten — erzwingt ein Tuple dies auf Sprachebene.
• Leichter Performance-Vorteil. Tuple-Iteration und -Erstellung sind geringfügig schneller als Listen-Operationen für dieselben Daten.

# Using a tuple as a dictionary key
locations = {}
locations[(48.8566, 2.3522)] = 'Paris'
locations[(51.5074, -0.1278)] = 'London'
print(locations[(48.8566, 2.3522)])
# Output: Paris

Übungen