Schleifen

Schleifen#

Oft müssen im Code verschiedene Blöcke mehrmals durchgeführt werden. Ist die Anzahl oder die Menge der Wiederholungen vorher bekannt, verwendet man dafür den for-Loop. Man unterscheidet zwei Arten von For-Loops:

  • For-Loop: Wiederhole die Schleife genau \(n\) mal

  • For-Each-Loop (Iterator): Wiederhole die Schleife für jedes Element in einer Sequenz

For-Loop bei bekannter Anzahl an Wiederholungen#

For-Each-Loop bei Sequenzen#

Der for-Loop in Python ist ein For-Each-Loop. Er iteriert immer durch eine Sequenz an Werten, wie z.B. eine Liste. Die Variable des Iterators e enthält dabei den aktuellen Wert der Sequenz seq. Hiermit lässt sich sehr leicht durch Listen iterieren.

seq = ['a','b','c']
for e in seq:
	print(e)

a
b
c

oder Tupels

seq = ('a','b','c')
for e in seq:
	print(e)

a
b
c

For-Loop bei bekannter Anzahl \(n\) an Wiederholungen#

Der for-Loop in Python kann auch als klassischer For-Loop verwendet werden, bei der man \(n\)-mal etwas wiederholt. Dazu erzeugt man mit der range(n) Funktion eine Folge an Zahlen, durch die dann wie gewohnt als For-Each-Loop iteriert wird. Der Iterator i nimmt dabei den Wert des Zählindexes an.

n = 3
seq = range(n)
for i in seq:
	print(i)

0
1
2

Der Unterschied wird klarer, wenn man sich ansieht, wie man mit einem nummerierten Index durch die obige Sequenz einer Liste laufen würde. Hierfür bestimmt man die Länge der Sequenz mit len(), erzeugt einen numerischen Iterator mit range() und greift dann auf die indizierten Werte der Liste mit seq[i] zu. Dies entspricht einem klassischen for-Loop durch ein Array, wie er z.B. in C oder Java zu finden ist.

seq = ['a','b','c']
for i in range(len(seq)):
    wert = seq[i]
    print(f"Index: {i}; Wert {wert}")

Index: 0; Wert a
Index: 1; Wert b
Index: 2; Wert c

Da dies sehr umständlich ist, bietet Python die enumerate-Funktion als Vereinfachung an. Sie macht aus einer beliebigen Sequenz eine nummerierte Sequenz macht. Das ist Sinnvoll, wenn man den Index i noch aus anderem Grund braucht.

seq = ['a','b','c']
for i, wert in enumerate(seq):
	print(f"Index: {i}; Wert {wert}")

Index: 0; Wert a
Index: 1; Wert b
Index: 2; Wert c

For-Each-Loop bei Dictionaries#

Auch durch Dictionaries kann man mit einem For-Loop iterieren. Hierfür kann man entweder durch die Schlüssel iterieren und dann den Wert separat über seq[key] nachschlagen.

seq = {"key1":"wert1", "key2":"wert2", "key3":"wert3"}
for key in seq:
    wert = seq[key]
    print(f"Schlüssel: {key}; Wert {wert}")

Schlüssel: key1; Wert wert1
Schlüssel: key2; Wert wert2
Schlüssel: key3; Wert wert3

oder man iteriert gleich durch alle Schlüssel-Wert-Tupel.

for key, wert in seq.items():
    print(f"Schlüssel: {key}; Wert {wert}")

Schlüssel: key1; Wert wert1
Schlüssel: key2; Wert wert2
Schlüssel: key3; Wert wert3

For-Loop Beispiel#

Damit kann man dann zum Beispiel eine Liste an Messwerten aus imperialen Fuß in metrische Meter umrechnen.

measurements_feet =  [4.2, 2.3, 6.2, 10.5]	# Eingabe
measurements_meter = []						# Ergebnisse
for feets in measurements_feet:
	measurements_meter.append(0.3048 * feets)

print(measurements_meter)

[1.2801600000000002, 0.70104, 1.88976, 3.2004]

In Python gibt es für solche einfachen For-Loops auch wieder eine Kurzschreibweise als Syntax-Zucker.

measurements_meter = [0.3048 * feets for feets in measurements_feet]

print(measurements_meter)

[1.2801600000000002, 0.70104, 1.88976, 3.2004]

While-Loops bei unbekanner Schleifenlänge#

While-Loops werden primär verwendet, wenn die Länge der Schleife am Anfang noch nicht bekannt ist. Dabei wird die Schleife so lange wiederholt, wie eine bestimmte Bedingung gegeben ist. Man unterscheidet in der Informatik die Typen:

  • While-Loop: Wiederhole solange eine Bedingung wahr ist (ggf. nie)

  • Do-While-Loop: Wiederhole bis eine Bedingung falsch ist (d.h. mindestens einmal)

  • Repeat-Until-Loop: Wiederhole bis eine Bedingung wahr wird (d.h. mindestens einmal)

While-Loop#

Im While-Loop kann die Bedingung schon am Anfang falsch sein. Die Schleife muss also nicht ausgeführt werden.

n = 3
while n > 0:
		print(f"Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife {n} > 0 wahr ist")
		n -= 1 # wir zählen die variable n runter

Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife 3 > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife 2 > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife 1 > 0 wahr ist

Die While-Schleife wird 3-mal ausgeführt da die Bedingung wahr ist und wir bis 0 runter zählen

Die While-Schleife wird nicht ausgeführt, da n bereits 0 ist

n = 0
while n > 0:
		print(f"Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife {n} > 0 wahr ist")
		n -= 1 # wir zählen die variable n runter

Do-While-Loops#

Im Do-While-Loop wird die Bedingung erst am Ende geprüft. Die Schleife wird also immer mindestens einmal durchlaufen. Das ist jedoch identisch im Verhalten mit einem While-Loop bei der die Bedingung am Anfang als True gesetzt wurde und in der Schleife geändert wird.

n = 3
bedingung = True # Bedingung ist immer als True innitialisiert
while bedingung:
	n -= 1 # wir zählen die variable n runter
	bedingung = n > 0 # Die bedingung wird erst am Ende der schleife neu gesetzt
	print(f"Die Do-While-Schleife wird mindestens einmal ausgeführt bis die Bedingung am Ende der Schleife {n} > 0 wahr ist")

Die Do-While-Schleife wird mindestens einmal ausgeführt bis die Bedingung am Ende der Schleife 2 > 0 wahr ist
Die Do-While-Schleife wird mindestens einmal ausgeführt bis die Bedingung am Ende der Schleife 1 > 0 wahr ist
Die Do-While-Schleife wird mindestens einmal ausgeführt bis die Bedingung am Ende der Schleife 0 > 0 wahr ist

Die Do-While-Schleife wird auch 3 mal ausgeführt da die Bedingung wahr ist und wir bis 0 runter zählen

Die Do-While-Schleife wird einmal ausgeführt, obwohl n bereits 0 ist.

n = 0
bedingung = True # Bedingung ist immer als True innitialisiert
while bedingung:
	n -= 1 # wir zählen die variable n runter
	bedingung = n > 0 # Die bedingung wird erst am Ende der schleife neu gesetzt
	print(f"Die Do-While-Schleife wird mindestens einmal ausgeführt bis die Bedingung am Ende der Schleife {n} > 0 wahr ist")

Die Do-While-Schleife wird mindestens einmal ausgeführt bis die Bedingung am Ende der Schleife -1 > 0 wahr ist

Repeat-Until-Loop#

Beim Repeat-Until-Loop wird die Bedingung auch erst am Ende geprüft. Die Schleife wird also auch immer mindestens einmal durchlaufen. Die Schleife wird allerdings wiederholt bis die Bedingung Wahr wird. Es ist also eine Negation des Do-While-Loops.

n = -3
bedingung = False # Bedingung ist immer als False innitialisiert
while not bedingung:  # wird aber im while negiert
	n += 1 # wir zählen die variable n HOCH
	bedingung = n > 0 # Die bedingung wird erst am Ende der schleife neu gesetzt
	print(f"Die Repeat-Until-Schleife wird mindestens einmal ausgeführt bis die Bedingung am Ende der Schleife {n} > 0 falsch ist")

Die Repeat-Until-Schleife wird mindestens einmal ausgeführt bis die Bedingung am Ende der Schleife -2 > 0 falsch ist
Die Repeat-Until-Schleife wird mindestens einmal ausgeführt bis die Bedingung am Ende der Schleife -1 > 0 falsch ist
Die Repeat-Until-Schleife wird mindestens einmal ausgeführt bis die Bedingung am Ende der Schleife 0 > 0 falsch ist
Die Repeat-Until-Schleife wird mindestens einmal ausgeführt bis die Bedingung am Ende der Schleife 1 > 0 falsch ist

Die Repeat-Until-Schleife wird 3 mal ausgeführt, da die Bedingung am Anfang falsch ist und wir bis 0 hoch zählen.

Die Do-While-Schleife wird einmal ausgeführt, da n am Ende der Schleife > 0 ist.

n = 0
bedingung = False # Bedingung ist immer als False innitialisiert
while not bedingung:  # wird aber im while negiert
	n += 1 # wir zählen die variable n HOCH
	bedingung = n > 0 # Die bedingung wird erst am Ende der schleife neu gesetzt
	print(f"Die Repeat-Until-Schleife wird mindestens einmal ausgeführt bis die Bedingung am Ende der Schleife {n} > 0 falsch ist")

Die Repeat-Until-Schleife wird mindestens einmal ausgeführt bis die Bedingung am Ende der Schleife 1 > 0 falsch ist

Endloos-Schleifen#

Warning

While-Schleifen haben keine maximale Wiederholungsanzahl. Sie können potentiell für immer laufen, wenn sich die Bedingung nie ändert. Es ist daher immer wichtig zu durchdenken, ob es den Fall gibt in dem sich die Bedingung nicht ändern kann und dann eine zweite Abbruchbedingung (z.B. maximale Iterationen, maximale Zeit, etc.) hinzuzufügen.

Wir schauen uns unsere while_loop-Funktion noch einmal an. Wie könnte diese Funktion zu einer Endlosschleife werden?

while n > 0:
	print(f"Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife {n} > 0 wahr ist")
	n -= 1 # wir zählen die variable n runter

Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife 1 > 0 wahr ist

Es sieht erstmal so aus, als ob das nicht möglich ist. Wir werden dennoch sicherheitshalber eine zweite Variante mit zusätzlicher Abbruchbedingung definieren.

def while_loop_mit_abbruch(n, max_iterations=99):
	iterations = 0
	while n > 0 and iterations < max_iterations:
		print(f"Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife {n} > 0 wahr ist")
		n -= 1 # wir zählen die variable n runter
		iterations += 1
	print(f"Die While-Schleife wurde nach {iterations} von {max_iterations} beendet")

Der obige Testfall mit 3 scheint zu funktionieren.

while_loop_mit_abbruch(3)

Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife 3 > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife 2 > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife 1 > 0 wahr ist
Die While-Schleife wurde nach 3 von 99 beendet

Was passiert allerdings wenn wir die Funktion mit Unendlich (Infinity) initialisieren? Die Subtraktion/Addition einer Zahl, ungleich Unendlich, zu Unendlich ist Unendlich. Die Variable n wird sich also nie ändern.

import math # die Zahl unendlich ist in der math bibliothek definiert

while_loop_mit_abbruch(math.inf)

Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wird ausgeführt wenn die Bedingung am Anfang der Schleife inf > 0 wahr ist
Die While-Schleife wurde nach 99 von 99 beendet

Schleifen vorzeitig abbrechen oder Elemente überspringen#

Manchmal möchte man eine for/while-Schleife verfrüht abbrechen. Hierfür bietet Python den break–Befehl. Er bricht die Wiederholschleife an der aktuellen Position ab (ähnlich wie repeat in einer Funktion). Damit lassen sich zusätzliche Abbruchbedingungen in der Schleife implementieren.

Der continue-Befehl bricht die Schleife nicht ab, sondern beginnt direkt die nächste Iteration. Das ist sinnvoll wenn z.B. eine Filterbedingung nicht erfüllt ist.

Der folgende Loop soll das erste essbare Ding in meinem Rucksack finden.

dinge_in_meinem_rucksack = ["Papier", "Stift", "Apfel", "Brot", "Messer"]
essbares = {"Apfel", "Brot"}
essbar = None

for ding in dinge_in_meinem_rucksack:   # Finde das erste essbare Ding in meinem Rucksack
	if ding not in essbares:
		print(f"Überspringe {ding}")
		continue
	print(f"Essbares gefunden {ding}")
	essbar = ding
	break

print("")
print(f"Ergebnis ist {essbar}")

Überspringe Papier
Überspringe Stift
Essbares gefunden Apfel

Ergebnis ist Apfel

Wir sehen, dass der Loop Papier und Stift überspringt und nicht "Essbares gefunden Papier" schreibt.

Sobald der Loop etwas Essbares gefunden hat, so gibt er "Essbares gefunden Apfel" aus und beendet den Loop, obwohl noch Brot und Messer im Rucksack sind.

Beides sind typische Befehle, um die Performance von Loops zu verbessern.

Endlosschleifen mit Timeout#

Mit break lassen sich zusätzliche Abbruchbedingungen realisieren, wie z.B. eine maximale Ausführzeit. Z.B. definieren wie einen zusätzlichen Timeout in einer Endlosschleife von 10 Sekunden mit Hilfe der time()-Funktion aus dem Paket time, welche die aktuelle Zeit (seit 1970) in Sekunden ausgibt.

import time

iterations = 0
start = time.time() # wir speichern die Anfangszeit
while True:         # DAS IST EINE ENDLOSSCHLEIFE
	iterations += 1
	elapsed = time.time() - start  # wir berechnen die Zeitdifferenz in Sekunden
	if elapsed > 3:
		print(f"Timeout after {elapsed}s and {iterations} iterations")
		break       # Wir brechen die Schleife ab

Timeout after 3.000000238418579s and 15996502 iterations

Das ist allerdings keine gute Methode um ein Programm eine Zeit lang zu unterbrechen. Dafür sollten Sie lieber die sleep() Funktion aus dem Paket time nutzen. Beachten Sie die Ausführungszeit unter der Zelle.

start = time.time()              # wir speichern die Anfangszeit

time.sleep(3)                    # wir schlafen 3s

print(f"Sleeped for {time.time() - start}s")  # wir geben die Zeitdifferenz aus

Sleeped for 3.0002667903900146s
Contents