Schleifen

2.3.1. Schleifen#

Schleifen ermöglichen das systematische Iterieren bzw. Wiederholen von Anweisungen.

Im Maximum-Algorithmus, werden Schleifen benutzt um alle Elemente der Eingabeliste durchzulaufen und deren Wert zu evaluieren.

Typen von Schleifen#

In Python können zwei Arten von Schleifen definiert werden: while- und for-Schleifen. Beide benötigen zwei Definitionen:

  • Schleifenkopf, welcher die Ausführung des Anweisungsblocks steuert, und

  • Anweisungsblock, Gruppe von Anweisungen, welche bei jedem Schleifendurchlauf ausgeführt werden.

Welcher der beiden Typen verwendet wird, hängt von der jeweiligen Aufgabe ab. Die allgemeinere von beiden ist die while-Schleife, d.h. jede for-Schleife kann als eine while-Schleife umgeschrieben werden.

while-Schleifen#

Eine while-Schleife für den Anweisungsblock immer wieder aus solange die Ausführbedingung wahr ist. Formal sieht eine solche Schleife wie folgt aus:

while Bedingung:
    Anweisungsblock

Die Schleife wird mit dem Schlüsselwort while eingeleitet, gefolgt von der Ausführbedingung. Dieser Schleifenkopf wird mit einem Doppelpunkt : abgeschlossen. Darunter wird der eingerückte Anweisungsblock definiert, d.h. die Gruppe von Ausdrücken, welche kontinuierlich ausgeführt werden. Beim Beginn der Schleife und nach jedem Durchlauf wird die Bedingung geprüft. Ist sie wahr, so wird der Anweisungsblock ausgeführt, wenn nicht, ist die Schleife beendet und die nächste Anweisung außerhalb der Schleife ausgeführt.

Folgende Beispiele verdeutlichen die Funktionsweise der while-Schleife. Im ersten Fall wird eine Variable kontinuierlich erhöht bis sie einen Grenzwert erreicht und im zweiten Beispiel werden die Elemente einer Liste einzeln ausgegeben.

# Beispiel 1: Erhöhen eines Variablenwertes

# Setzte Startwert
a = 5

# Definiere Schleife, welche solange ausgeführt 
# wird, wie a kleiner als 10 ist
while a <= 10:
    # Anweisungsblock der Schleife:
    
    # 1. Ausgabe des aktuellen Werts von a 
    print('aktueller Wert von a', a)
    
    # 2. Erhöhung von a um Eins
    a += 1

# Ausgabe des Wertes nach der Schleife
print('Wert von a nach der Schleife', a)

aktueller Wert von a 5
aktueller Wert von a 6
aktueller Wert von a 7
aktueller Wert von a 8
aktueller Wert von a 9
aktueller Wert von a 10
Wert von a nach der Schleife 11

# Beispiel 2: Einzelausgabe von Listenelementen

# Definiere eine Liste
l1 = [34, -12.4, 'feuer', 0.3, 12]

# Definiere eine Laufvariable
i = 0

# Schleife, welche solgange durchlaufen wird, wie
# die Laufvariable kleiner als die Länge der Liste ist
while i < len(l1):
    print('Beginn des Ausführungsblocks, Wert der Laufvariablen:', i)
    # Ausgabe des Elements mit dem Index i
    print('Element mit dem Index', i, 'hat den Wert:', l1[i])
    print()
    # Erhöhung der Laufvariablen
    i += 1

Beginn des Ausführungsblocks, Wert der Laufvariablen: 0
Element mit dem Index 0 hat den Wert: 34

Beginn des Ausführungsblocks, Wert der Laufvariablen: 1
Element mit dem Index 1 hat den Wert: -12.4

Beginn des Ausführungsblocks, Wert der Laufvariablen: 2
Element mit dem Index 2 hat den Wert: feuer

Beginn des Ausführungsblocks, Wert der Laufvariablen: 3
Element mit dem Index 3 hat den Wert: 0.3

Beginn des Ausführungsblocks, Wert der Laufvariablen: 4
Element mit dem Index 4 hat den Wert: 12

for-Schleifen#

Während die while-Schleifen ausgeführt werden, solange eine Bedingung erfüllt ist, werden for-Schleifen alle Elemente einer Sequenz, z.B. einer Liste, ausgeführt. Dazu wird eine Laufvariable generiert, welche bei jedem Durchlauf des Anweisungsblocks den aktuellen Wert aus der Sequenz einnimmt. Die Syntax sieht wie folgt aus:

for Laufvariable in Sequenz:
    Anweisungsblock

Zur Definition des Schleifenkopfes gehören die beiden Schlüsselworte for und in und der Kopf wird mit einem Doppelpunkt : abgeschlossen. Auch hier wird der Anweisungsblock eingerückt.

Als Sequenz können beispielsweise Listen, Ranges (Datenstrukturen, welche durch die range-Funktion erzeugt werden), Zeichenketten oder Dateien verwendet werden.

Die obigen Beispiele können auch mit einer for-Schleife programmiert werden.

# Beispiel 3: Erhöhen eines Variablenwertes

# Definiere Schleife, welche eine passende Range durchläuft
for a in range(5, 11):
    # Anweisungsblock der Schleife:
    
    # Ausgabe des aktuellen Werts von a 
    print('aktueller Wert von a', a)

aktueller Wert von a 5
aktueller Wert von a 6
aktueller Wert von a 7
aktueller Wert von a 8
aktueller Wert von a 9
aktueller Wert von a 10

# Beispiel 4: Einzelausgabe von Listenelementen

# Definiere eine Liste
l1 = [34, -12.4, 'feuer', 0.3, 12]

# Schleife, welche für alle Elemente der Liste l1 ausgeführt wird
for i in l1:
    print('Wert der Laufvariablen:', i)

Wert der Laufvariablen: 34
Wert der Laufvariablen: -12.4
Wert der Laufvariablen: feuer
Wert der Laufvariablen: 0.3
Wert der Laufvariablen: 12

Verschachtelte Schleifen#

Es können mehrere Schleifen kombiniert werden. Dazu befindet sich die innere Schleife im Anweisungsblock der äußeren Schleife.

Folgendes Beispiel verdeutlicht diesen Einsatz beim Zugriff auf eine Liste mit Listenelementen. Dabei iteriert die äußere Schleife über die Elemente der Liste, welche selbst wieder Listen sind.

l2 = [[1, 2], [11, 22, 33, 44], [111, 222, 333]]

for el_l2 in l2:
    
    print( "Beginn der inneren Schleife für die Liste:", el_l2 )
    
    for el in el_l2:
        print( "Element:", el )
        
    print( "Ende der inneren Schleife")
    print()
    

Beginn der inneren Schleife für die Liste: [1, 2]
Element: 1
Element: 2
Ende der inneren Schleife

Beginn der inneren Schleife für die Liste: [11, 22, 33, 44]
Element: 11
Element: 22
Element: 33
Element: 44
Ende der inneren Schleife

Beginn der inneren Schleife für die Liste: [111, 222, 333]
Element: 111
Element: 222
Element: 333
Ende der inneren Schleife

Im obigen Beispiel kann bequem auf die Elemente zugegriffen werden, jedoch sind die Indizes nicht verfügbar. Eine alternative Möglickeit des Zugriffs ist der Einsatz von Indizes, welche über den jeweiligen Indexbereich laufen.

print( "== Beginn der äußeren Schleife" )
print()

for i in range(len(l2)):
    
    print( "Äußerer Index: ", i )
    print( "Beginn der inneren Schleife für die Liste:", l2[i] )
    
    for j in range(len(l2[i])):
        print( "Element mit dem Index ", i, j, "hat den Wert", l2[i][j] )
        
    print( "Ende der inneren Schleife")
    print()
    
print( "== Ende der äußeren Schleife" )

== Beginn der äußeren Schleife

Äußerer Index:  0
Beginn der inneren Schleife für die Liste: [1, 2]
Element mit dem Index  0 0 hat den Wert 1
Element mit dem Index  0 1 hat den Wert 2
Ende der inneren Schleife

Äußerer Index:  1
Beginn der inneren Schleife für die Liste: [11, 22, 33, 44]
Element mit dem Index  1 0 hat den Wert 11
Element mit dem Index  1 1 hat den Wert 22
Element mit dem Index  1 2 hat den Wert 33
Element mit dem Index  1 3 hat den Wert 44
Ende der inneren Schleife

Äußerer Index:  2
Beginn der inneren Schleife für die Liste: [111, 222, 333]
Element mit dem Index  2 0 hat den Wert 111
Element mit dem Index  2 1 hat den Wert 222
Element mit dem Index  2 2 hat den Wert 333
Ende der inneren Schleife

== Ende der äußeren Schleife
Contents