Direkt zum Inhalt

Python Schleifen Tutorial

Ein umfassendes Einführungsseminar zu Python-Schleifen. Lerne und übe while- und for-Schleifen, verschachtelte Schleifen, die Schlüsselwörter break und continue, die Bereichsfunktion und vieles mehr!
Aktualisierte 16. Jan. 2025  · 22 Min. Lesezeit

range Python

Schleifen sind in Python oder in jeder anderen Programmiersprache wichtig, da sie dir helfen, einen Codeblock wiederholt auszuführen. Du wirst oft mit Situationen konfrontiert, in denen du einen Teil des Codes immer wieder verwenden musst, aber nicht dieselbe Codezeile mehrmals schreiben willst.

In diesem Python-Loops-Tutorial wirst du die folgenden Themen behandeln:

While-Schleife

Die while-Schleife ist eine der ersten Schleifen, auf die du wahrscheinlich stößt, wenn du anfängst, programmieren zu lernen. Sie ist wohl auch eine der am intuitivsten zu verstehenden: Wenn du an den Namen dieser Schleife denkst, wirst du schnell verstehen, dass das Wort "while" etwas mit "Intervall" oder einer "Zeitspanne" zu tun hat. Wie du bereits weißt, bezieht sich das Wort "Schleife" auf einen Teil des Codes, den du wiederholt ausführst.

Wenn du das alles bedenkst, kannst du die folgende Definition der while-Schleife leicht verstehen:

Eine while-Schleife ist ein Programmierkonzept, bei dem ein Teil des Codes immer wieder ausgeführt wird, solange eine bestimmte Bedingung erfüllt ist.

Die obige Definition verdeutlicht auch die drei Komponenten, die du brauchst, um die while-Schleife in Python zu konstruieren:

  • Das Schlüsselwort while;
  • Ein Zustand, der entweder auf True oder False übergeht; und
  • Ein Codeblock, den du wiederholt ausführen willst

Das ist alles, was du brauchst!

Wie man eine While-Schleife in Python erstellt

Jetzt, da du weißt, was du für den Aufbau einer while-Schleife brauchst, musst du dir nur noch ein Beispiel aus der Praxis ansehen, in dem die while-Schleife verwendet wird, bevor du mit deinen eigenen Übungen beginnst! Betrachte das folgende Beispiel:

# Take user input
number = 2  

# Condition of the while loop
while number < 5 :  
    print("Thank you")
    # Increment the value of the variable "number by 1"
    number = number+1
Thank you
Thank you
Thank you

Das obige Codebeispiel ist eine sehr einfache while-Schleife: Wenn du darüber nachdenkst, sind die drei Komponenten, über die du zuvor gelesen hast, alle vorhanden: das Schlüsselwort while, gefolgt von einer Bedingung, die entweder True oder False (number < 5) bedeutet, und einem Codeblock, den du wiederholt ausführen willst:

print("Thank you")
number = number + 1

Wenn du im obigen Code ins Detail gehst, siehst du, dass es eine Variable number gibt, in der du eine Ganzzahl 2 speicherst. Da der Wert in number kleiner als 5 ist, druckst du "Thank you" aus und erhöhst den Wert von number um eins. Solange der Wert in number kleiner als 5 ist, führst du die beiden Codezeilen aus, die in der while-Schleife enthalten sind:

"Thank you"
"Thank you"

Du druckst "Danke" noch zwei weitere Male aus, bevor der Wert von number gleich 5 ist und die Bedingung nicht mehr auf True ausgewertet wird. Da die Bedingung jetzt False ergibt, beendest du die while-Schleife und setzt dein Programm fort, wenn es noch weiteren Code enthält. In diesem Fall gibt es keinen Code mehr und dein Programm bleibt stehen.

Das obige Beispiel ist ein wenig einfach, du kannst auch Bedingungen einfügen, oder, mit anderen Worten, eine Wenn-Bedingung, um es noch individueller zu gestalten. Sieh dir das folgende Beispiel an:

# Take user input
number = 2 

# Condition of the while loop
while number < 5 :  
    # Find the mod of 2
    if number%2 == 0:  
        print("The number "+str(number)+" is even")
    else:
        print("The number "+str(number)+" is odd")

    # Increment `number` by 1
    number = number+1
The number 2 is even
The number 3 is odd
The number 4 is even

Also, lass uns üben!

Schreibe eine Funktion collatz(), mit der der Benutzer eine ganze Zahl in eine Variable namens number eingeben kann. Wenn die Zahl gerade ist, sollte sie das Ergebnis von number/2 ausgeben. Wenn die Zahl ungerade ist, dann sollte collatz() drucken und 3 * number + 1 zurückgeben. Das Programm sollte die Funktion collatz() auf number so lange aufrufen, bis es ein 1 zurückgibt.

Beachte, dass es sich hierbei um eine Umsetzung der Collatz-Folge handelt, also um ein mathematisches Problem, bei dem du eine Zahl auswählst und die obigen Berechnungen so lange durchführst, bis du das Ergebnis 1 erhältst.

Unten findest du die Lösung:

def collatz(number):
    # Is the mod of 2 equal to 0?
    if number % 2 == 0:
        print(number // 2)
        return number // 2

    # If the mod of 2 isn't equal to 0, print `3 * number + 1`
    elif number % 2 == 1:
        result = 3 * number + 1
        print(result)
        return result

# Ask input from the user    
n = input("Give me a number: ")

# As long as `n` is not equal to `1`, run `collatz()`
while n != 1:
    n = collatz(int(n))
Give me a number: 5
16
8
4
2
1

Python kostenlos lernen

Einführung in Python

BeginnerSkill Level
4
6M learners
Beherrsche die Grundlagen der Datenanalyse mit Python in nur vier Stunden. Dieser Online-Kurs führt in die Python-Schnittstelle ein und stellt beliebte Pakete vor.
See DetailsRight Arrow

Intermediate Python

BeginnerSkill Level
4
1.2M learners
Verbessere deine Data Science-Fähigkeiten, indem du mit Matplotlib Visualisierungen erstellst und DataFrames mit Pandas manipulierst.

For-Schleife

Du kannst die for-Schleife auf die gleiche Weise angehen wie die while-Schleife. Wie du wahrscheinlich erwartet hast, bezieht sich die "for"-Komponente in "for loop" auf etwas, das du eine bestimmte Anzahl von Malen machst.

Wenn du das alles im Kopf behältst, kannst du die for-Schleife ganz einfach wie folgt definieren:

Eine for-Schleife ist ein Programmierkonzept, das, wenn es implementiert ist, einen Teil des Codes immer wieder "für" eine bestimmte Anzahl von Malen ausführt, basierend auf einer Sequenz.

Im Gegensatz zur while-Schleife gibt es hier keine aktive Bedingung - du führst einfach einen Code eine bestimmte Anzahl von Malen aus. Mit anderen Worten: Während die while-Schleife den in ihr enthaltenen Codeblock nur so lange ausführt, bis die Bedingung True erfüllt ist, führt die for-Schleife den in ihr enthaltenen Code nur eine bestimmte Anzahl von Malen aus. Diese "Anzahl von Malen" wird durch eine Reihenfolge oder eine geordnete Liste von Dingen bestimmt.

Du wirst gleich mehr über den Unterschied zwischen while- und for-Schleifen erfahren, aber konzentriere dich erst einmal auf die folgenden Teile, die du brauchst, um eine for-Schleife zu erstellen:

  • Das Schlüsselwort for
  • Eine Variable
  • Das Schlüsselwort in
  • Die Funktion range() ist eine eingebaute Funktion in der Python-Bibliothek, um eine Zahlenfolge zu erstellen.
  • Der Code, den du wiederholt ausführen willst

For-Schleifen in Python

# Print "Thank you" 5 times
for number in range(5):
    print("Thank you")
Thank you
Thank you
Thank you
Thank you
Thank you

Wie du siehst, kehren die Komponenten, die du im obigen Abschnitt gesehen hast, in diesem kleinen Beispiel für eine for-Schleife in Python wieder: das Schlüsselwort for, die Variable number, das Schlüsselwort in, die Funktion range() und der Code, den du mehrmals ausführen willst, print("Thank you").

Das ist doch nicht so schwer, oder?

Betrachten wir ein weiteres Beispiel für eine for-Schleife, in der du zwei Variablen verwendest, um deinen Kontrollfluss zu definieren:

languages = ['R', 'Python',  'Scala', 'Java', 'Julia']

for index in range(len(languages)):
   print('Current language:', languages[index])
Current language: R
Current language: Python
Current language: Scala
Current language: Java
Current language: Julia

Wie du sehen kannst, beginnst du die Schleife mit dem Schlüsselwort for. Als Nächstes verwendest du die Variablen index und languages, das Schlüsselwort in und die Funktion range(), um eine Zahlenreihe zu erstellen. Außerdem siehst du, dass du in diesem Fall auch die Funktion len() verwendest, da die Liste languages nicht numerisch ist. Das Stück Code, das du wiederholt ausführen willst, ist eine Druckanweisung, nämlich print('Current language :', languages[index]).

In der obigen Schleife willst du ausdrücken, dass du für jeden Index im Bereich len(languages) die Data Science Programmiersprache ausgeben möchtest. Nun ist len(languages) gleich 5, also könnte die Aussage auch wie folgt umgeschrieben werden:

for index in range(5):
    print('Current language:', languages[index])
Current language: R
Current language: Python
Current language: Scala
Current language: Java
Current language: Julia

Und auch hier erhältst du das gleiche Ergebnis!

While- versus For-Schleifen in Python

Schauen wir uns noch einmal das allererste Beispiel der while-Schleife an, um herauszufinden, was nun genau die Unterschiede zwischen while- und for-Schleifen sind. Du hast oben bereits gelesen, dass der Unterschied in der Bedingung liegt, die beteiligt ist oder nicht, aber wie spiegelt sich das im Code wider und wie kannst du vielleicht zwischen den beiden wechseln?

# Take user input
number = 2  

while number < 5 :
    print("Thank you")
    # Increment `number` by 1
    number = number+1
Thank you
Thank you
Thank you

Du kannst die for-Schleife verwenden, um die Aussage "Danke" kontrollierter zu drucken:

# Print "Thank you" 3 times
for number in range(3) :  
    print("Thank you")
Thank you
Thank you
Thank you

Siehst du, wie einfach es war, die while-Schleife in eine entsprechende for-Schleife umzuwandeln?

Wie funktioniert das, fragst du? Nun, das ist ganz einfach.

In einer for-Schleife ist die in der range-Funktion angegebene ganze Zahl der Bereich oder die Anzahl der Schleifen, die das Steuerelement durchlaufen und den Code in der for-Schleifen-Klausel ausführen muss.

Beachte, dass die Zählung bei der Funktion range() bei 0 und nicht bei 1 beginnt. Das bedeutet, dass die Zählung im obigen Beispiel 0,1,2 und nicht 1,2,3 lauten sollte. So funktioniert das Zählen von Zahlen im Speicher eines Computers. Wenn du also eine for-Schleife entwirfst, solltest du immer daran denken, dass du die Anzahl der Bereiche ab 0 und nicht ab 1 berücksichtigen musst.

Tipp: Das gilt z.B. auch für Listen in Python. Wenn du mehr über Python-Listen wissen möchtest, solltest du dir das DataCamp-Tutorial 18 Most Common Python List Questions ansehen.

Es gibt einen weiteren interessanten Unterschied zwischen einer for-Schleife und einer while-Schleife. Eine for-Schleife ist schneller als eine while-Schleife. Um das zu verstehen, musst du dir das folgende Beispiel ansehen.

import timeit

# A for loop example
def for_loop():
    for number in range(10000) :  
        # Execute the below code 10000 times
        sum = 3+4
        #print(sum)

timeit.timeit(for_loop)
267.0804728891719
import timeit

# A while loop example
def while_loop():
    i =0
    while i<10000:
        sum = 3+4
        #print(sum)
        i+=1

timeit.timeit(while_loop)
884.9233417965908

In dem obigen Codeabschnitt hast du zwei Schleifen mit etwa 10000 Iterationen. Auf den ersten Blick sehen beide gleich aus, bis du hinter die Kulissen schaust und verstehst, wie diese beiden Schleifen funktionieren. Tipp: Die Funktion timeit() gibt dir einen Hinweis darauf, was der Unterschied sein könnte!

Zur Erinnerung: Der gesamte Python-Code wird mit einem C-Compiler kompiliert, d.h. der Code, den du oben siehst, wird zunächst in Byte-Codes zerlegt und dann von dem zugrunde liegenden C-Compiler verarbeitet.

Wenn die Ausführung der for-Schleife im obigen Beispiel beginnt, spricht der Python-Interpreter mit dem zugrundeliegenden C-Compiler und erstellt dann ein Listenobjekt der Größe 10000. Als Nächstes wird ein Iterator aufgerufen, um den Index für jedes der 10000 Elemente in der Liste aufzurufen.

Bei der Ausführung der while-Schleife wird hingegen kein Listenobjekt erstellt. Tatsächlich ruft der zugrunde liegende C-Compiler den booleschen Vergleichsoperator für die Bedingung i<10000 9999 Mal auf.

Du kannst dir schon vorstellen, dass es für den Compiler einfacher ist, über ein bereits erstelltes Listenobjekt mit 10000 Elementen zu iterieren, als eine boolesche Operation 9999 Mal zu wiederholen; die Zeitleistung einer for-Schleife ist besser als die einer while-Schleife. Das spiegelt sich deutlich in der Ausführungszeit wider: Die Zeit, die die for-Schleife braucht, um fertig zu werden, ist viel kleiner als die Zeit, die die while-Schleife braucht, um fertig zu werden.

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgU2V0IGBmaWJfbm9gIHRvIDU1LCB0aGUgbnVtYmVyIHVudGlsIHdoZXJlIHlvdSB3YW50IHRvIHByaW50XG5maWJfbm8gPSA1NVxuXG4jIFNldCBgZmlyc3Rfbm9gIHRvIDBcbmZpcnN0X25vID0gMFxuXG4jIFNldCBgc2Vjb25kX25vYCB0byAxXG5zZWNvbmRfbm8gPSAxXG5cbiMgU2V0IHRoZSBjb3VudGVyIGBjb3VudGAgdG8gMCBcbmNvdW50ID0gMFxuXG4jIHdoaWxlIGxvb3AgdG8gcHJpbnQgdGhlIGZpYm9uYWNjaSBzZXJpZXMgdW50aWwgdGhlIGBmaWJfbm9gXG53aGlsZSBmaXJzdF9ubyA8PSBmaWJfbm86XG4gICAgICAgIyBQcmludCBgZmlyc3Rfbm9gXG4gICAgICAgcHJpbnQoZmlyc3Rfbm8pXG4gICAgICAgXG4gICAgICAgIyBGaWJvbm5hY2NpIG51bWJlclxuICAgICAgIG50aCA9IGZpcnN0X25vICsgX19fX19fX19fX1xuICAgICAgIFxuICAgICAgICMgdXBkYXRlIHZhbHVlcyBvZiBgZmlyc3Rfbm9gIGFuZCBgc2Vjb25kX25vYFxuICAgICAgIGZpcnN0X25vID0gX19fX19fX19fX19fXG4gICAgICAgc2Vjb25kX25vID0gX19fXG4gICAgICAgXG4gICAgICAgIyBTZXQgY291bnRlciBgY291bnRgICsxXG4gICAgICAgX19fX19fX19fXyIsInNvbHV0aW9uIjoiIyBTZXQgYGZpYl9ub2AgdG8gNTUsIHRoZSBudW1iZXIgdW50aWwgd2hlcmUgeW91IHdhbnQgdG8gcHJpbnRcbmZpYl9ubyA9IDU1XG5cbiMgU2V0IGBmaXJzdF9ub2AgdG8gMFxuZmlyc3Rfbm8gPSAwXG5cbiMgU2V0IGBz

Probiere jetzt die for-Schleife aus! Beachte, dass du den Bereich von 0 bis 11 angeben musst, da du nur die Zahlen in der Reihenfolge bis 55 anzeigen willst, was die 11.

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgSW5pdGlhbGl6ZSBgZmlyc3Rfbm9gIHRvIGAwYFxuZmlyc3Rfbm8gPSAwXG5cbiMgSW5pdGlhbGl6ZSBgc2Vjb25kX25vYCB0byBgMWBcbnNlY29uZF9ubyA9IDFcblxuIyBJbml0aWFsaXplIGBudW1iZXJzYFxubnVtYmVycyA9IF9fX19fX19fX19fXG5cbiMgRmluZCBhbmQgZGlzcGxheSBGaWJvbmFjY2kgc2VyaWVzXG5mb3IgbnVtIGluIF9fX19fX186XG4gICAgICAgICAgIGlmKG51bSA8PSAxKTpcbiAgICAgICAgICAgIyBVcGRhdGUgb25seSBgbnRoYFxuICAgICAgICAgICAgICAgICAgICAgIG50aCA9IF9fX1xuICAgICAgICAgICBlbHNlOlxuICAgICAgICAgICAjIFVwZGF0ZSB0aGUgdmFsdWVzIGBudGhgLCBgZmlyc3Rfbm9gIGFuZCBgc2Vjb25kX25vYFxuICAgICAgICAgICAgICAgICAgICAgIG50aCA9IGZpcnN0X25vICsgc2Vjb25kX25vXG4gICAgICAgICAgICAgICAgICAgICAgZmlyc3Rfbm8gPSBzZWNvbmRfbm9cbiAgICAgICAgICAgICAgICAgICAgICBzZWNvbmRfbm8gPSBfX19fX19fX19fXG4gICAgICAgICAgICAgICAgICAgICAgXG4gICAgICAgICAgICMgUHJpbnQgYG50aGBcbiAgICAgICAgICAgcHJpbnQobnRoKSIsInNvbHV0aW9uIjoiIyBJbml0aWFsaXplIGBmaXJzdF9ub2AgdG8gYDBgXG5maXJzdF9ubyA9IDBcblxuIyBJbml0aWFsaXplIGBzZWNvbmRfbm9gIHRvIGAxYFxuc2Vjb25kX25vID0gMVxuICAgICAgICAgICBcbiMgSW5pdGlhbGl6ZSBgbnVtYmVyc2Bc

Verschachtelte Schleifen

Wie du im obigen Beispiel sehen kannst, gibt es innerhalb der while-Schleife eine if-else-Bedingung, mit der du weitere Bedingungen in deinen Code einfügen kannst.

Halt dich fest!

Das ist nicht die einzige Möglichkeit, wie du deine Schleife anpassen kannst. Du kannst auch eine weitere while-Schleife in deinen bestehenden Code einfügen, die als verschachtelte Schleife bezeichnet wird. Du kannst das obige Beispiel abändern, um eine weitere while-Schleife wie unten einzubauen:

# Take user input
number = 2 

# condition of the while loop
while number < 5 :  
    # condition of the nested while loop    
    while number % 2 == 0: 
        print("The number "+ str(number)+" is even")

Im obigen Beispiel gibt es eine weitere while-Schleife, die in der äußeren Schleife "verschachtelt" ist. In dieser inneren Schleife wird geprüft, ob number % (mod) 2 0 ist.

Mit anderen Worten: Er prüft, ob die Zahl gerade ist und gibt dann die Aussage "Die Zahl ist gerade" aus.

Aber es gibt einen Haken: Wenn du genau hinsiehst, kannst du sehen, dass wie im vorherigen Code die Anweisung number=number+1 dieses Mal fehlt. Da du die Variablennummer nirgendwo inkrementierst, bleibt der Wert der Variablen jedes Mal gleich und der Code gerät in eine Endlosschleife. Das bedeutet, dass er die Schleife nie wieder verlässt und die Anweisung unendlich oft ausgibt, weil die Variable number immer auf 2 gesetzt wird. Diese Zahl ist natürlich kleiner als 5 und eine gerade Zahl.

Schauen wir uns nun an, wie eine verschachtelte for-Schleife aussehen würde:

# Print the below statement 3 times
for number in range(3) :  
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    # Inner loop
    for another_number in range(5):  
        print("****************************")
        print("I am inner loop iteration "+str(another_number))
-------------------------------------------
I am outer loop iteration 0
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4
-------------------------------------------
I am outer loop iteration 1
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4
-------------------------------------------
I am outer loop iteration 2
****************************
I am inner loop iteration 0
****************************
I am inner loop iteration 1
****************************
I am inner loop iteration 2
****************************
I am inner loop iteration 3
****************************
I am inner loop iteration 4

Der obige Code ist eine modifizierte Version des ersten for-Schleifen-Beispiels. Beachte, dass innerhalb der äußeren Schleife eine zweite for-Schleife verwendet wird.

Fahre fort und führe den Code aus.

Du wirst feststellen, dass die Steuerung in die erste for-Schleife eintritt und der Wert der Variablen number mit 0 initialisiert wird. Die erste Druckanweisung wird gedruckt, und dann tritt die Steuerung in die zweite for-Schleife ein, in der der Wert der Variablen another_number auf 0 initialisiert wird. Die erste Druckanweisung in der zweiten for-Schleife wird einmal gedruckt.

Jetzt kehrt die Steuerung wieder zur inneren for-Schleife zurück und der Wert von another_number wird erneut auf die nächste Ganzzahl initialisiert, gefolgt vom Drucken der Anweisung innerhalb der Funktion print().

Der oben beschriebene Prozess wird fortgesetzt, bis das Steuerelement das Ende der Funktion range() durchlaufen hat, was in diesem Fall 5 ist. Dann kehrt das Steuerelement zur äußersten Schleife zurück, initialisiert die Variable number auf die nächste Ganzzahl, druckt die Anweisung innerhalb der Funktion print() aus, besucht die innere Schleife und wiederholt dann alle oben genannten Schritte, bis die Funktion range() durchlaufen wurde.

Diese Reise des Steuerelements von der äußersten Schleife, über die innere Schleife und dann wieder zurück zur äußeren for-Schleife wird fortgesetzt, bis das Steuerelement den gesamten Bereich durchlaufen hat, in deinem Fall also dreimal.

Nachdem du nun einige Erklärungen zu verschachtelten Schleifen gelesen hast, ist es an der Zeit, selbst loszulegen! Schreibe ein Python-Programm, um das folgende Muster mit einer verschachtelten for-Schleife zu erstellen: loops Python

eyJsYW5ndWFnZSI6InB5dGhvbiIsInNhbXBsZSI6IiMgSW5pdGlhbGl6ZSB0aGUgZmlyc3QgZml2ZSByb3dzXG5uID0gX1xuXG4jIFN0YXJ0IHRoZSBsb29wIHRvIHByaW50IHRoZSBmaXJzdCBmaXZlIHJvd3NcbmZvciBpIGluIHJhbmdlKF8pOlxuICAgIGZvciBqIGluIHJhbmdlKGkpOlxuICAgICAgICBwcmludCgnKiAnLCBlbmQ9XCJcIilcbiAgICBwcmludCgnJylcblxuIyBTdGFydCB0aGUgbG9vcCB0byBwcmludCB0aGUgcmVtYWluaW5nIHJvd3MgaW4gZGVjcmVhc2luZyBvcmRlciBvZiBzdGFyc1xuZm9yIGkgaW4gcmFuZ2UobiwwLC0xKTpcbiAgICBmb3IgaiBpbiByYW5nZShfKTpcbiAgICAgICAgcHJpbnQoJyogJywgZW5kPVwiXCIpXG4gICAgcHJpbnQoJycpIiwic29sdXRpb24iOiIjIEluaXRpYWxpemUgdGhlIGZpcnN0IGZpdmUgcm93c1xubiA9IDVcblxuIyBTdGFydCB0aGUgbG9vcCB0byBwcmludCB0aGUgZmlyc3QgZml2ZSByb3dzXG5mb3IgaSBpbiByYW5nZShuKTpcbiAgICBmb3IgaiBpbiByYW5nZShpKTpcbiAgICAgICAgcHJpbnQoJyogJywgZW5kPVwiXCIpXG4gICAgcHJpbnQoJycpXG5cbiMgU3RhcnQgdGhlIGxvb3AgdG8gcHJpbnQgdGhlIHJlbWFpbmluZyByb3dzIGluIGRlY3JlYXNpbmcgb3JkZXIgb2Ygc3RhcnNcbmZvciBpIGluIHJhbmdlKG4sMCwtMSk6XG4gICAgZm9yIGogaW4gcmFuZ2UoaSk6XG4gICAgICAgIHByaW50KCcqICcsIGVuZD1cIlwiKVxuICAgIHByaW50KCcnKSIsInNjdCI6IkV4KCkuaGFzX2VxdWFs

break und continue Schlüsselwörter: Endlosschleifen erstellen

Du kannst break und continue in jeder von dir erstellten Schleife verwenden. Diese Schlüsselwörter sind nicht darauf beschränkt, absichtliche Endlosschleifen zu unterbrechen, aber sie sollten vorsichtig eingesetzt werden. Beide Schlüsselwörter erschweren es anderen - und auch dir selbst, wenn du in ein paar Monaten auf deinen Code zurückblickst - den Kontrollfluss in der Schleife zu verstehen und wo die Bedingung endet. Außerdem brauchst du die Schlüsselwörter break und continue nicht zu verwenden: Wie du bisher gesehen hast, kommst du auch ohne sie zurecht!

In manchen Fällen kann es jedoch sinnvoller sein, absichtliche Endlosschleifen zu schreiben, als die traditionellen for- und while-Schleifen, die du bisher gesehen hast. In diesen Fällen ist die Verwendung dieser Schlüsselwörter natürlich erwünscht!

Unterbrechen und Fortsetzen von While-Schleifen in Python

Glücklicherweise gibt es eine Möglichkeit, aus der oben beschriebenen Endlosschleife auszubrechen, und zwar mit dem Schlüsselwort break.

# Take user input
number = 2 

# Condition of the while loop
while number < 5 :  
    # condition of the nested while loop
    while number % 2 == 0:  
        print("The number "+str(number)+" is even")
        break

    number+=1

Wenn du den obigen Code ausführst, gerät er nicht mehr in eine Endlosschleife.

"Was ist das für eine Zauberei!", schreist du. - Ich sage: "Ganz ruhig, das ist keine Zauberei.

Wenn die Steuerung auf das Schlüsselwort break stößt, versteht sie, dass sie die Schleife (in diesem Fall die innere Schleife) verlassen muss und führt die nächste Codezeile aus. Deshalb bricht er aus der inneren while-Schleife aus und geht zur äußeren Schleife über, wo er seine üblichen Aufgaben erledigt, bis die Bedingung in der äußeren while-Schleife erfüllt ist.

Du solltest bedenken, dass nach dem Schlüsselwort break eine Codezeile stehen muss, sonst hat es keine Wirkung. Versuche, die Codezeile nach dem Schlüsselwort break im obigen Beispiel zu entfernen und führe den Code dann aus.

Was ist, wenn du das Schlüsselwort continue nach der Anweisung break einfügst? Du kannst dem untenstehenden Code folgen:

# Take user input
number = 2 

while number < 5 :
    while number % 2 == 0: 
        print("The number "+str(number)+" is even")
        break

    continue

    number+=1

Der obige Code ist eine leicht abgewandelte Version des Beispiels für das Schlüsselwort break.

Wenn du den obigen Code ausführst, wirst du wieder auf eine Endlosschleife stoßen. Bevor du dir vor lauter Frust die Haare raufst, sieh dir das mal genauer an. Du wirst feststellen, dass es nach der Pause ein continue Schlüsselwort gibt. Das Schlüsselwort continue überträgt die Kontrolle zurück an die äußerste Schleife, noch bevor die Variable number inkrementiert wird, und dadurch gerät der Code in eine Endlosschleife.

For-Schleifen unterbrechen und fortsetzen

Was wäre, wenn du die innere for-Schleife im obigen Beispiel nicht für den gesamten Bereich ausführen wolltest? Du kannst die Anweisung break auf ähnliche Weise verwenden wie bei der while-Schleife.

# Print the below statement 3 times
for number in range(3) : 
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    for another_number in range(3):
        print("****************************")
        print("I am inner loop iteration "+str(another_number))
        break

Im obigen Beispiel weist das Schlüsselwort break nach der inneren Schleife die Steuerung an, die innere Schleife zu verlassen, woraufhin die Steuerung zur äußeren Schleife zurückkehrt.

Führe das folgende Codebeispiel aus:

# Print the below statement 3 times
for number in range(3) :  
    print("-------------------------------------------")
    print("I am outer loop iteration "+str(number))
    continue
    for another_number in range(3):
        print("****************************")
        print("I am inner loop iteration "+str(another_number))
        break

Im obigen Code wird nur die äußerste Schleife ausgeführt und die Steuerung berührt die innere Schleife nicht einmal.

"Warum?", fragst du.

Sieh dir den Code genauer an. Direkt nach der zweiten Druckanweisung in der äußersten Schleife gibt es das Schlüsselwort continue. Es weist die Steuerung an, zur äußeren for-Schleife zurückzuspringen und von vorne zu beginnen. Deshalb berührt die Steuerung nie die innere Schleife.

Anders als bei der while-Schleife brauchst du in der for-Schleife kein Stück Code nach dem Schlüsselwort break. Eine Unterbrechungsschleife allein funktioniert auch innerhalb einer for-Schleife gut.

range() gegen xrange()

Diese beiden Funktionen sind einander ähnlich, aber wenn du Python 3 verwendest, steht dir nur die Funktion range() zur Verfügung. In Python 3.x wird die Funktion xrange() in range() umbenannt. Das heißt, wenn du versuchst, die Funktion xrange() mit Python 3 zu verwenden, bekommst du den Fehler NameError: name 'xrange' is not defined.

Um zu verstehen, wie ähnlich diese beiden Funktionen sind, betrachte das folgende Beispiel:

# Print the below statement 3 times
for number in range(5,10,2) :  
    print("I am number : "+str(number))
I am number : 5
I am number : 7
I am number : 9

Wenn du den obigen Code ausführst, wirst du sehen, dass der Wert der Variablen number um den Faktor 2 übersprungen wird, und zwar wegen der Parameter in der Funktion range().

Der erste Parameter in dieser Funktion ist der Startparameter. Das ist der Punkt, ab dem die Kontrolle zu zählen beginnt. Der zweite Parameter ist der Stopp-Parameter, der den Punkt angibt, an dem die Kontrolle anhalten muss, und der letzte Parameter ist die Schrittfunktion, die den Faktor festlegt, um den die Kontrolle beim Zählen springen muss.

Im obigen Fall beginnt die Kontrolle also bei 5 und durchläuft die Schleife bis 9, wobei bei jeder Zählung 2 hinzugefügt wird. Das bedeutet 5, 5+2=7, 7+2=9.

Du hast gelernt, wie die Funktion range() verwendet wird, um die Anzahl der Schleifen festzulegen, die dein Code durchlaufen muss. In Python 2.x gibt es noch eine weitere Möglichkeit, dies zu tun, und zwar mit der Funktion xrange(). Führe den folgenden Code aus:

# Print the below statement 3 times
for number in xrange(10) :  
    print("I am number : "+str(number))
I am number : 0
I am number : 1
I am number : 2
I am number : 3
I am number : 4
I am number : 5
I am number : 6
I am number : 7
I am number : 8
I am number : 9

Welchen Unterschied siehst du in der Ausgabe des obigen Codes im Vergleich zu der Ausgabe des Codes ohne die Funktion xrange()? Kein Unterschied?

Das ist richtig. Du wirst keinen Unterschied in der Ausgabe des Codes sehen.

Warum solltest du also die Funktion xrange() verwenden? Dazu kommst du etwas später im Tutorium. Führe zuerst den folgenden Code aus:

print(xrange(10))
print(range(10))
xrange(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Du kannst sehen, dass es in der Ausgabe des obigen Codes einen Unterschied in der Ausgabe der beiden Druckanweisungen gibt. In der Druckanweisung, die die Funktion xrange() enthält, bekommst du das Funktionsobjekt xrange() gedruckt. Das ist bei der Druckanweisung mit der Funktion range() anders: Dort erhältst du eine Liste mit ganzen Zahlen von 0 bis 9.

Und genau das ist der Unterschied zwischen der Funktion range() und der Funktion xrange().

Wenn du die Funktion range() definierst, wird eine Liste des gesamten Bereichs im RAM gespeichert und dir präsentiert. Wenn du die Funktion xrange() definierst, wird jedoch keine Liste im Speicher abgelegt. Stattdessen erzeugt die Funktion xrange() ganze Zahlen im gesamten Bereich, wenn du sie brauchst. Auf diese Weise trägt die Funktion xrange() dazu bei, den Speicher in einem ressourcenarmen System zu schonen.

Verbessere deine Python-Kenntnisse!

Herzlichen Glückwunsch, du hast es bis zum Ende dieses Tutorials geschafft. Nachdem du nun gelernt hast, wie man Schleifen in Python verwendet, kannst du jetzt üben. Je mehr du übst, desto besser!

Themen

Verwandte Python-Kurse

Zertifizierung verfügbar

Kurs

Einführung in Python

4 hr
6M
Beherrsche die Grundlagen der Datenanalyse mit Python in nur vier Stunden. Dieser Online-Kurs führt in die Python-Schnittstelle ein und stellt beliebte Pakete vor.
Siehe DetailsRight Arrow
Kurs starten
Mehr anzeigenRight Arrow