Tuples in Python verbinden

Python-Tuples sind unveränderliche Sequenzen — einmal erstellt, können ihre Elemente weder hinzugefügt, entfernt noch geändert werden. Tuples zu verbinden bedeutet, ein neues Tuple zu erstellen, das den Inhalt von zwei oder mehr bestehenden Tuples kombiniert. Da Tuples unveränderlich sind, gibt jede Verbindungsoperation ein neues Tuple zurück, anstatt die Originale zu ändern.

Diese Seite behandelt die wichtigsten Möglichkeiten, Tuples in Python zu verbinden:

• +-Operator — zwei oder mehr Tuples verketten
• *-Operator — ein Tuple eine bestimmte Anzahl von Malen wiederholen
• tuple()-Konstruktor — ein Tuple aus einem beliebigen Iterable erstellen, nützlich beim Kombinieren von Nicht-Tuple-Sequenzen

Tuples mit dem +-Operator verbinden

Der +-Operator verkettet zwei Tuples zu einem einzigen neuen Tuple. Die Elemente des linken Operanden kommen zuerst, gefolgt von denen des rechten Operanden. Keines der Originale wird verändert.

Ausgabe:

(1, 2, 3, 4, 5, 6)

Drei oder mehr Tuples verbinden

Den +-Operator verketten, um beliebig viele Tuples in einem einzigen Ausdruck zusammenzuführen:

Ausgabe:

(1, 2, 3, 4, 5, 6, 7, 8, 9)

Tuples mit gemischten Typen verbinden

Tuples können Werte verschiedener Typen enthalten, und + funktioniert dabei genauso:

t1 = (1, "hello", True)
t2 = (3.14, None)
result = t1 + t2
print(result)

Ausgabe:

(1, 'hello', True, 3.14, None)

Achtung: Beide Operanden müssen Tuples sein

+ kann nicht verwendet werden, um ein Tuple mit einer Liste oder einem anderen Typ zu verketten — Python wirft einen TypeError. Die andere Sequenz muss zuerst in ein Tuple umgewandelt werden:

my_tuple = (1, 2, 3)
my_list = [4, 5, 6]

# This raises TypeError:
# result = my_tuple + my_list

# Correct — convert the list to a tuple first:
result = my_tuple + tuple(my_list)
print(result)

Ausgabe:

(1, 2, 3, 4, 5, 6)

Achtung: Syntax für einelementige Tuples

Ein Tuple mit einem Element benötigt ein abschließendes Komma. Ohne es behandelt Python die Klammern als Gruppierung, nicht als Tuple-Literal:

not_a_tuple = (42)    # int, not tuple
singleton   = (42,)   # tuple with one element

result = singleton + (1, 2)
print(result)

Ausgabe:

(42, 1, 2)

Ein Tuple mit dem *-Operator wiederholen

Der *-Operator wiederholt ein Tuple eine bestimmte Anzahl von Malen und gibt ein neues Tuple zurück. Das ist nützlich, wenn eine Sequenz mit einem wiederholten Muster vorbelegt werden soll.

t = ("a", "b")
result = t * 3
print(result)

Ausgabe:

('a', 'b', 'a', 'b', 'a', 'b')

Die ganze Zahl kann auf beiden Seiten stehen: t * 3 und 3 * t erzeugen das gleiche Ergebnis. Die Multiplikation mit 0 oder einer negativen Zahl gibt ein leeres Tuple zurück.

t = (1, 2, 3)
print(t * 0)   # ()
print(t * 1)   # (1, 2, 3)

Ausgabe:

()
(1, 2, 3)

Ein kombiniertes Tuple mit tuple() erstellen

Der eingebaute tuple()-Konstruktor konvertiert ein beliebiges Iterable in ein Tuple. Damit lässt sich ein kombiniertes Tuple aus einer Liste erstellen, die durch Anhängen aufgebaut wurde — das ist effizienter als wiederholte +-Aufrufe innerhalb einer Schleife.

parts = [1, 2, 3]
parts += [4, 5, 6]        # build up a list first
combined = tuple(parts)   # convert to tuple once
print(combined)

Ausgabe:

(1, 2, 3, 4, 5, 6)

Warum + in einer Schleife vermeiden

Jeder +-Aufruf erstellt ein neues Tuple-Objekt und kopiert alle Elemente. Beim Verbinden vieler Tuples bedeutet das O(n²) Kopien. Das effiziente Muster ist, alle Elemente in einer Liste zu sammeln und diese am Ende einmalig umzuwandeln:

tuples = [(1, 2), (3, 4), (5, 6), (7, 8)]

# Inefficient — creates a new tuple on each iteration
result = ()
for t in tuples:
    result = result + t   # many intermediate copies

# Efficient — build a list, convert once
result = tuple(item for t in tuples for item in t)
print(result)

Ausgabe:

(1, 2, 3, 4, 5, 6, 7, 8)

Tuples verbinden vs. verschachteln

Es passiert leicht, Tuples versehentlich zu verschachteln statt sie zu verbinden. Der +-Operator glättet eine Ebene; Tuples in ein neues Tuple einzuschließen erzeugt eine verschachtelte Struktur.

t1 = (1, 2)
t2 = (3, 4)

joined = t1 + t2      # flat: all four elements at the same level
nested = (t1, t2)     # two-element tuple of tuples

print("joined:", joined)
print("nested:", nested)

Ausgabe:

joined: (1, 2, 3, 4)
nested: ((1, 2), (3, 4))

+ verwenden, wenn ein flaches Ergebnis gewünscht wird. (t1, t2) verwenden, wenn bewusst ein Tuple von Tuples benötigt wird (zum Beispiel eine Tabelle mit Zeilen).

Den richtigen Ansatz wählen

Verwandte Themen

• Python Tuples — Tuples erstellen, indizieren und slicen
• Auf Tuples zugreifen — Tuple-Elemente indizieren und slicen
• Tuples aktualisieren — Workarounds zum Ändern unveränderlicher Tuples
• Tuples entpacken — Tuple-Elemente Variablen zuweisen
• Tuples durchlaufen — über Tuple-Elemente iterieren
• Tuple-Methoden — Referenz zu count() und index()
• Listen verbinden — Listen mit +, extend() und mehr zusammenführen

Übungen