tuple()

Einleitung

Tupel und Listen sind beide geordnete Sequenzen. Drei wesentliche Unterschiede:

1. Immutability: Tupel können nach der Erzeugung nicht verändert werden — kein append, pop, Index-Zuweisung.
2. Hashable (wenn alle Elemente hashable sind): Tupel können als Dict-Keys oder Set-Elemente dienen.
3. Semantik: Listen für Sammlungen gleichartiger Dinge, Tupel oft für strukturierte Records („Geocoordinate" = (lat, lon)).

Die Literal-Syntax ist (a, b, c) — eigentlich machen die Klammern allein noch kein Tupel, sondern die Komma-Separation. 1, 2, 3 ist auch schon ein Tupel.

tuple() selbst wird vor allem zum Konvertieren von Iterables genutzt — z. B. eine Liste in ein Tupel umzuwandeln, um sie als Dict-Key zu verwenden.

Syntax

tuple()         # leeres Tupel
tuple(iterable) # Tupel aus Iterable

Rückgabewert

Eine neue tuple-Instanz mit den Elementen des Iterables in Iterations-Reihenfolge.

Beispiele

Aus verschiedenen Quellen

tuple() funktioniert mit allen Iterables — nicht nur Listen:

print(tuple())                # leer
print(tuple([1, 2, 3]))
print(tuple("abc"))
print(tuple(range(4)))
print(tuple({"a": 1, "b": 2}))   # Keys

()
(1, 2, 3)
('a', 'b', 'c')
(0, 1, 2, 3)
('a', 'b')

Tupel-Literal

Die Literal-Syntax wird im Alltag häufiger benutzt als der Konstruktor. Achtung: ein Element braucht ein nachgestelltes Komma:

a = (1, 2, 3)
b = 1, 2, 3                # Klammern nicht nötig
c = (1,)                    # Single-Element: Komma!
d = (1)                     # KEIN Tupel — int
print(type(a), type(b), type(c), type(d))

<class 'tuple'> <class 'tuple'> <class 'tuple'> <class 'int'>

Tupel als Dict-Key

Da Tupel hashable sind, können sie als Schlüssel verwendet werden — perfekt für mehrdimensionale Lookups:

chess = {}
chess[(1, 1)] = "Turm"
chess[(1, 2)] = "Springer"
chess[(1, 8)] = "Turm"

print(chess[(1, 2)])

Springer

Unpacking

Tupel-Unpacking ist eines der wichtigsten Pythonismen — perfekt für Funktions-Rückgabewerte:

def divmod_pair(a, b):
    return a // b, a % b

quotient, remainder = divmod_pair(17, 5)
print(quotient, remainder)

# Star-Unpacking
first, *middle, last = (1, 2, 3, 4, 5)
print(first, middle, last)

3 2
1 [2, 3, 4] 5

Praktische Beispiele

Liste in Tupel für hashability umwandeln

Wer eine Liste als Set-Element oder Dict-Key braucht, muss sie zuerst in ein Tupel verwandeln:

seen = set()
rows = [[1, 2], [3, 4], [1, 2], [5, 6]]
unique_rows = []
for row in rows:
    key = tuple(row)
    if key not in seen:
        seen.add(key)
        unique_rows.append(row)
print(unique_rows)

[[1, 2], [3, 4], [5, 6]]

Records mit collections.namedtuple

Wer Tupel als Records nutzt, sollte namedtuple (oder dataclass) erwägen — mit benannten Feldern statt magischen Indizes:

from collections import namedtuple
Point = namedtuple("Point", ["x", "y"])

p = Point(3, 4)
print(p.x, p.y)
print(p[0], p[1])           # Tupel-Index funktioniert weiterhin
print(tuple(p))

3 4
3 4
(3, 4)

Mehrere Werte tauschen

Tupel-Unpacking macht das klassische Variablen-Tauschen ohne Hilfsvariable möglich:

a, b = 1, 2
a, b = b, a
print(a, b)

# Auch in Schleifen praktisch
x, y = 0, 1
for _ in range(8):
    x, y = y, x + y
print(y)   # 8. Fibonacci-Zahl

2 1
21

Praktische Hinweise

• Tupel sind hashable, Listen nicht — relevant für Dict-Keys und Set-Elemente.
• Single-Element-Tupel braucht Komma: (1,) ist ein Tupel, (1) nur ein int.
• namedtuple oder dataclass(frozen=True) für strukturierte Records — bessere Lesbarkeit.
• Performance: Tupel sind kompakter im Speicher und etwas schneller zu erstellen als Listen.
• Verwandte Typen: list (mutable), frozenset (mutable Set), collections.namedtuple (benannte Felder), dataclasses.dataclass (für moderne Records).