Tuples durchlaufen in Python

Beim Durchlaufen eines Tuples besuchen Sie jedes Element einzeln und können darauf reagieren. Da Tuples unveränderliche Sequenzen sind — ihr Inhalt kann sich nicht ändern — ist das Iterieren über sie sicher und unkompliziert. Diese Seite behandelt alle gängigen Techniken: for-Schleifen, while-Schleifen, enumerate(), range(len()), zip(), die Durchquerung verschachtelter Tuples sowie die Schleifensteuerung mit break/continue.

Wenn Sie neu bei Tuples sind, lesen Sie zuerst Python Tuples. Die allgemeine Schleifensyntax finden Sie unter Python For Loops und Python While Loops.

Mit einer for-Schleife

Die einfachste und pythonischste Methode, ein Tuple zu durchlaufen, ist eine for-Schleife. Python geht jedes Element der Reihe nach durch und weist es der Schleifenvariablen zu.

Ein Tuple mit einer for-Schleife durchlaufen

Ausgabe:

1
2
3
4
5

Die Schleife endet automatisch, wenn sie das letzte Element erreicht — kein Indexrechnen erforderlich.

Mit einer while-Schleife

Eine while-Schleife gibt Ihnen manuelle Kontrolle über den Index. Sie ist nützlich, wenn Sie um mehr als einen Schritt vor- oder zurückspringen müssen oder wenn die Abbruchbedingung von etwas anderem als der Tuple-Länge abhängt.

Ein Tuple mit einer while-Schleife durchlaufen

my_tuple = ('apple', 'banana', 'cherry')
i = 0

while i < len(my_tuple):
    print(my_tuple[i])
    i += 1

Ausgabe:

apple
banana
cherry

Erhöhen Sie i immer im Schleifenkörper, da die Schleife sonst ewig läuft.

Auf den Index zugreifen mit enumerate()

Wenn Sie sowohl die Position als auch den Wert benötigen, verwenden Sie enumerate(). Es verknüpft jedes Element mit seinem nullbasierten Index und gibt beides zusammen zurück.

Ein Tuple mit enumerate durchlaufen

colors = ('red', 'green', 'blue')

for index, color in enumerate(colors):
    print(index, color)

Ausgabe:

0 red
1 green
2 blue

Sie können die Zählung bei jeder beliebigen Zahl beginnen, indem Sie ein zweites Argument übergeben:

enumerate ab 1 beginnen

colors = ('red', 'green', 'blue')

for index, color in enumerate(colors, start=1):
    print(index, color)

Ausgabe:

1 red
2 green
3 blue

enumerate() wird gegenüber range(len()) bevorzugt, wenn Sie sowohl Index als auch Wert benötigen, da es lesbarer ist und den zusätzlichen Indexierungsschritt vermeidet.

Auf den Index zugreifen mit range(len())

Ein älteres, aber nach wie vor gültiges Muster verwendet range(len()), um die gültigen Indizes zu erzeugen, und greift dann positionsweise auf jedes Element zu.

Ein Tuple mit range und len durchlaufen

fruits = ('apple', 'banana', 'cherry')

for i in range(len(fruits)):
    print(i, fruits[i])

Ausgabe:

0 apple
1 banana
2 cherry

Dieser Ansatz ist praktisch, wenn Sie benachbarte Elemente vergleichen oder eine abgeleitete Liste positionsbasiert ändern müssen, da sowohl der Index als auch der Wert gleichzeitig verfügbar sind.

Über verschachtelte Tuples iterieren

Ein Tuple kann andere Tuples enthalten. Verwenden Sie eine verschachtelte for-Schleife, um die inneren Werte zu erreichen.

Über ein verschachteltes Tuple (Matrix) iterieren

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

for row in matrix:
    for value in row:
        print(value, end=' ')
    print()

Ausgabe:

1 2 3 
4 5 6 
7 8 9 

Jede Iteration der äußeren Schleife liefert ein inneres Tuple (row). Die innere Schleife durchläuft dann dieses innere Tuple Element für Element.

Sie können das innere Tuple auch direkt im Schleifenkopf entpacken, wenn die Form festgelegt ist:

Innere Tuples beim Durchlaufen entpacken

points = ((0, 0), (1, 2), (3, 4))

for x, y in points:
    print(f'x={x}, y={y}')

Ausgabe:

x=0, y=0
x=1, y=2
x=3, y=4

Dadurch liest sich der Code fast wie normales Deutsch und vermeidet row[0]- / row[1]-Indizierungen. Weitere Informationen zum Entpacken finden Sie unter Unpack Tuples.

Zwei Tuples parallel mit zip() durchlaufen

zip() kombiniert Elemente aus zwei (oder mehr) Tuples nach Position und ermöglicht es Ihnen, sie in einer Schleife zu entpacken.

Zwei Tuples parallel durchlaufen

names = ('Alice', 'Bob', 'Carol')
scores = (95, 87, 92)

for name, score in zip(names, scores):
    print(name, score)

Ausgabe:

Alice 95
Bob 87
Carol 92

zip() stoppt, sobald das kürzeste Tuple erschöpft ist, sodass unterschiedliche Längen keinen Fehler auslösen — sie werden stillschweigend abgeschnitten. Wenn Sie alle Paare benötigen und Lücken füllen möchten, verwenden Sie stattdessen itertools.zip_longest() aus der Standardbibliothek.

Schleifensteuerung: break und continue

Frühzeitig stoppen mit break

break beendet die Schleife sofort, wenn eine Bedingung erfüllt ist.

Eine Tuple-Schleife frühzeitig mit break stoppen

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

for n in numbers:
    if n == 4:
        break
    print(n)

Ausgabe:

1
2
3

Die Schleife gibt 1, 2, 3 aus und stoppt dann, wenn sie auf 4 trifft.

Elemente überspringen mit continue

continue springt zur nächsten Iteration, ohne den restlichen Code im Schleifenkörper auszuführen.

Gerade Zahlen mit continue überspringen

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

for n in numbers:
    if n % 2 == 0:
        continue
    print(n)

Ausgabe:

1
3
5

Nur die ungeraden Zahlen werden ausgegeben; gerade Zahlen werden stillschweigend übersprungen.

Eine Liste aus einer Tuple-Schleife erstellen

Da Tuples unveränderlich sind, können Sie sie nicht an Ort und Stelle ändern. Ein gängiges Muster ist, ein Tuple zu durchlaufen und die Ergebnisse in einer neuen Liste zu sammeln.

Eine Liste mit Quadraten aus einem Tuple erstellen

numbers = (1, 2, 3, 4, 5)
squares = [n ** 2 for n in numbers]
print(squares)

Ausgabe:

[1, 4, 9, 16, 25]

Der List-Comprehension-Ausdruck durchläuft das Tuple genauso wie eine for-Schleife und ist bei einfachen Transformationen kompakter. Weitere Informationen zur Arbeit mit Tuple-Daten finden Sie unter Python Tuples und Tuple Methods.

Wann welche Technik verwenden

Übung