Listen durchlaufen

Eine Liste durchlaufen — jeden Eintrag einzeln besuchen — ist eine der häufigsten Operationen in Python. Dieses Kapitel behandelt alle praktischen Methoden dafür: for-Schleifen, while-Schleifen, enumerate(), zip(), break und continue sowie List Comprehensions. Außerdem werden Fallstricke erklärt, die beim Verändern einer Liste während der Iteration auftreten können.

Warum eine Liste durchlaufen?

Eine Python-Liste enthält eine geordnete Folge von Elementen. Schleifen ermöglichen es, auf jedes Element zu reagieren, ohne für jedes Element eine eigene Codezeile schreiben zu müssen. Ob du Preise summierst, Datensätze filterst oder Zeichenketten transformierst – eine Schleife ist meist das richtige Werkzeug.

Durchlaufen mit einer for-Schleife

Der einfachste und lesbarste Weg, über eine Liste zu iterieren, ist eine for-Schleife.

fruits = ['apple', 'banana', 'cherry']
for fruit in fruits:
    print(fruit)

apple
banana
cherry

Python weist jedes Element der Reihe nach fruit zu, führt den eingerückten Block aus und geht dann zum nächsten Element. Die Schleife stoppt automatisch, wenn die Liste erschöpft ist – eine manuelle Indexverwaltung ist nicht nötig.

Durchlaufen mit range() und einem Index

Wenn du sowohl den Index als auch den Wert benötigst, kannst du range() mit len() kombinieren:

colors = ['red', 'green', 'blue']
for i in range(len(colors)):
    print(i, colors[i])

0 red
1 green
2 blue

Das funktioniert, aber enumerate() (im nächsten Abschnitt) ist für dieses Muster übersichtlicher.

Durchlaufen mit enumerate()

enumerate() paart jedes Element mit seinem Index und ist der idiomatische Python-Ansatz, wenn beides benötigt wird:

fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
    print(index, fruit)

0 apple
1 banana
2 cherry

Du kannst den Zähler bei einer anderen Zahl starten, indem du ein zweites Argument übergibst:

for index, fruit in enumerate(['apple', 'banana', 'cherry'], start=1):
    print(index, fruit)

1 apple
2 banana
3 cherry

Zwei Listen mit zip() durchlaufen

zip() paart Elemente aus zwei (oder mehr) Listen, sodass du sie nebeneinander iterieren kannst:

names  = ['Alice', 'Bob', 'Carol']
scores = [92, 85, 78]

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

Alice -> 92
Bob -> 85
Carol -> 78

Haben die Listen unterschiedliche Längen, stoppt zip() bei der kürzeren. Verwende itertools.zip_longest(), wenn du bis zum Ende der längeren Liste fortfahren möchtest.

Durchlaufen mit einer while-Schleife

Eine while-Schleife läuft so lange, wie eine Bedingung True ist. Du verwaltest den Index selbst:

numbers = [10, 20, 30, 40, 50]
i = 0
while i < len(numbers):
    print(numbers[i])
    i += 1

10
20
30
40
50

while-Schleifen sind nützlich, wenn die Abbruchbedingung nicht einfach „Ende der Liste" ist – zum Beispiel bei der Suche nach einem Element, die stoppt, sobald es gefunden wurde.

Schleifenausführung steuern

break — Vorzeitig beenden

break beendet die Schleife sofort. Das ist nützlich, wenn du gefunden hast, was du gesucht hast, und nicht weiter iterieren musst:

fruits = ['apple', 'banana', 'cherry', 'date']
for fruit in fruits:
    if fruit == 'cherry':
        print('Found it!')
        break
    print(fruit)

apple
banana
Found it!

continue — Ein Element überspringen

continue springt zur nächsten Iteration, ohne die verbleibenden Zeilen des aktuellen Blocks auszuführen:

numbers = [1, 2, 3, 4, 5, 6]
for n in numbers:
    if n % 2 == 0:
        continue        # skip even numbers
    print(n)

1
3
5

Die else-Klausel bei einer Schleife

Eine for- oder while-Schleife kann einen else-Block haben, der ausgeführt wird, wenn die Schleife ohne einen break endet. Das ist praktisch für „Suchen und Melden"-Muster:

target = 7
numbers = [1, 3, 5, 9]

for n in numbers:
    if n == target:
        print('Found', target)
        break
else:
    print(target, 'not in list')

7 not in list

Einen Listenausschnitt durchlaufen

Du kannst einen Teil einer Liste durchlaufen, indem du sie slicest:

items = ['a', 'b', 'c', 'd', 'e']
for item in items[1:4]:   # indices 1, 2, 3
    print(item)

b
c
d

Rückwärts durchlaufen mit einem Slice:

for item in items[::-1]:
    print(item)

e
d
c
b
a

Verschachtelte Schleifen

Du kannst for-Schleifen verschachteln, um mit Listen von Listen zu arbeiten oder Kombinationen zu berechnen:

matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9],
]
for row in matrix:
    for value in row:
        print(value, end=' ')
    print()

1 2 3 
4 5 6 
7 8 9 

Die innere Schleife durchläuft alle ihre Iterationen für jede einzelne Iteration der äußeren Schleife.

List Comprehensions als Schleifen-Alternative

Eine List Comprehension erstellt eine neue Liste, indem ein Ausdruck auf jedes Element angewendet wird – sie ist eine kompakte, lesbare Alternative zu einer for-Schleife, die eine Liste aufbaut:

numbers = [1, 2, 3, 4, 5]

# for loop approach
squares = []
for n in numbers:
    squares.append(n ** 2)

# list comprehension — same result in one line
squares = [n ** 2 for n in numbers]

print(squares)

[1, 4, 9, 16, 25]

Du kannst eine Bedingung hinzufügen, um Elemente gleichzeitig zu filtern:

evens = [n for n in range(1, 11) if n % 2 == 0]
print(evens)

[2, 4, 6, 8, 10]

Häufiger Fallstrick: Liste während der Iteration verändern

Füge keine Elemente einer Liste hinzu oder entferne sie, während eine for-Schleife über genau diese Liste iteriert. Der interne Index der Schleife basiert auf der ursprünglichen Länge, sodass Elemente übersprungen oder doppelt besucht werden können.

# BAD — skips items
numbers = [1, 2, 3, 4, 5]
for n in numbers:
    if n % 2 == 0:
        numbers.remove(n)   # mutates the list mid-loop
print(numbers)              # [1, 3, 5] may look correct here but...

Das sichere Muster ist, über eine Kopie der Liste zu iterieren oder mit einer Comprehension eine neue Liste zu erstellen:

numbers = [1, 2, 3, 4, 5]
numbers = [n for n in numbers if n % 2 != 0]
print(numbers)

[1, 3, 5]

Grundlegende Listenoperationen in Verbindung mit Schleifen

Die folgenden Abschnitte fassen die Listenmethoden zusammen, die am häufigsten zusammen mit Schleifen verwendet werden. Siehe Python List Methods für die vollständige Referenz.

Elemente hinzufügen

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)

[1, 2, 3, 4]

Elemente entfernen

remove() löscht den ersten übereinstimmenden Wert und wirft einen ValueError, wenn das Element nicht gefunden wird.

my_list = [1, 2, 3, 4, 5]
my_list.remove(3)
print(my_list)

[1, 2, 4, 5]

Eine Liste sortieren

my_list = [3, 1, 4, 2, 5]
my_list.sort()
print(my_list)

[1, 2, 3, 4, 5]

sort() verändert die Liste direkt. Um eine sortierte Kopie zu erhalten, ohne das Original zu ändern, verwende die eingebaute Funktion sorted(). Siehe Sort Lists für Sortierung in umgekehrter Reihenfolge, Sortierung nach Schlüssel und mehr.

Verwandte Themen

• Python Lists — Listen erstellen, indexieren und slicen
• Python for Loops — die vollständige for-Schleifen-Referenz
• Python while Loops — while-Schleifen-Syntax und Muster
• List Comprehension — kompaktes einzeiliges Listen-Erstellen
• List Methods — append, extend, pop, insert und mehr
• Sort Lists — In-Place-Sortierung vs. sortierte Kopien
• Remove List Items — remove, pop, del und clear
• Loop Dictionaries — Schlüssel-Wert-Paare iterieren
• Loop Tuples — unveränderliche Sequenzen iterieren

Übungen