Python-Schleifen-Tutorial

For-Schleife

Du kannst die for-Schleife genauso angehen wie die while-Schleife. Wie du wahrscheinlich schon gedacht hast, geht es bei der „for“-Komponente in „for loop“ darum, dass du etwas ein paar Mal machst.

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

Eine for-Schleife ist ein Programmierkonzept, das, wenn es benutzt wird, einen Codeabschnitt immer wieder „for“ (für) eine bestimmte Anzahl von Malen ausführt, basierend auf einer Sequenz.

Im Gegensatz zur while-Schleife gibt's hier keine aktive Bedingung – du machst einfach einen Codeabschnitt ein paar Mal hintereinander. Also, während die while-Schleife den darin enthaltenen Code-Block nur so lange ausführt, bis die Bedingung nicht mehr stimmt ( True), macht die for-Schleife das nur so oft, wie es nötig ist. Diese „Anzahl“ 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 jetzt erstmal 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(), die in der Python-Bibliothek eingebaut ist, um eine Zahlenfolge zu erstellen.
• Der Code, den du immer wieder 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, tauchen die Komponenten, die du im obigen Abschnitt gesehen hast, auch in diesem kleinen Beispiel einer for-Schleife in Python wieder auf: das Schlüsselwort for, die Variable number, das Schlüsselwort in, die Funktion range() und der Code, den du mehrmals ausführen möchtest, print("Thank you").

Das ist doch nicht so schwer, oder?

Schauen wir uns noch ein Beispiel für eine for-Schleife an, wo du zwei Variablen benutzt, 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 siehst, startest du die Schleife mit dem Schlüsselwort for. Als Nächstes benutzt du die Variablen index und languages, das Schlüsselwort in und die Funktion range(), um eine Zahlenfolge zu erstellen. Außerdem siehst du, dass du in diesem Fall auch die Funktion len() benutzt, weil die Liste languages nicht numerisch ist. Der Code, den du wiederholt ausführen willst, ist eine print-Anweisung, nämlich print('Current language :', languages[index]).

In der Schleife oben willst du sagen, dass du für jeden Index im Bereich len(languages) die Datenwissenschaftsprogrammiersprache ausgeben willst. Jetzt ist len(languages) gleich 5, also könnte man die Aussage auch so umschreiben:

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 das bringt dir wieder das gleiche Ergebnis!

While- und For-Schleifen in Python

Schauen wir uns nochmal das allererste while-Schleifen-Beispiel an, um zu sehen, was genau die Unterschiede zwischen while- und for-Schleifen sind. Du hast oben schon gelesen, dass der Unterschied in der Bedingung liegt, die erfüllt ist oder nicht, aber wie sieht das im Code aus 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 nutzen, um die Aussage „Danke“ auf eine kontrolliertere Art und Weise auszugeben:

# 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 gleichwertige for-Schleife umzuwandeln?

Wie funktioniert das denn, fragst du? Naja, das ist ganz einfach.

In einer for-Schleife ist die in der range-Funktion erwähnte ganze Zahl der Bereich oder die Anzahl der Durchläufe, die die Steuerung durchlaufen und den Code in der for-Schleife ausführen muss.

Beachte, dass die Funktion range() bei 0 anfängt und nicht bei 1. Das heißt, im obigen Beispiel sollte die Zählung so aussehen: 0,1,2 und nicht 1,2,3. So läuft das Zählen von Zahlen im Speicher eines Computers ab. Denk also beim Entwerfen einer for-Schleife immer daran, dass du den Bereich von 0 und nicht von 1 ausgehend zählen musst.

Tipp: Das gilt zum Beispiel auch für Listen in Python. Wenn du mehr über Python-Listen erfahren möchtest, schau dir doch mal das Tutorial Die 18 häufigsten Fragen zu Python-Listen von DataCamp an.

Jetzt gibt's noch einen weiteren coolen 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 anschauen.

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

Im Code-Schnipsel oben hast du zwei Schleifen mit ungefähr 10.000 Durchläufen. Auf den ersten Blick sehen beide gleich aus, bis man hinter die Kulissen schaut und versteht, wie diese beiden Schleifen funktionieren. Tipp: Die Funktion timeit() gibt dir einen Hinweis darauf, was der Unterschied sein könnte!

Denk dran: Der ganze Python-Code wird mit einem C-Compiler kompiliert, was heißt, dass der Code, den du oben siehst, erst in Byte-Codes zerlegt und dann vom zugrunde liegenden C-Compiler verarbeitet wird.

Wenn die for-Schleife im obigen Beispiel losgeht, redet der Python-Interpreter mit dem C-Compiler und macht dann ein Listenobjekt mit der Größe 10000. Dann ruft es einen Iterator auf, um den Index jedes der 10.000 Elemente in der Liste zu durchlaufen.

Die Ausführung der while-Schleife macht dagegen kein Listenobjekt. Eigentlich 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, ein bereits erstelltes Listenobjekt mit 10.000 Elementen zu durchlaufen, als 9.999 Mal eine boolesche Operation durchzuführen. Die Zeitleistung einer for-Schleife ist besser als die einer while-Schleife. Das sieht man echt an der Ausführungszeit: Die Zeit, die die for-Schleife braucht, ist viel kürzer als die Zeit, die die while-Schleife braucht.

Probier jetzt mal die for-Schleife aus! Denk dran, dass du den Bereich von 0 bis 11 angeben musst, weil du nur die Zahlen in der Folge bis 55 anzeigen willst, also die 11. Zahl in der Folge.

Verschachtelte Schleifen

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

Warte mal!

Das ist nicht die einzige Möglichkeit, wie du deinen Loop anpassen kannst. Du kannst auch noch ein paar weitere while-Schleifen in deinen bestehenden Code einfügen. Das nennt man dann eine verschachtelte Schleife. Du kannst das obige Beispiel so ändern, dass es eine weitere while-Schleife enthält, wie unten gezeigt:

# 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's noch 'ne weitere while-Schleife, die in der äußeren Schleife „verschachtelt” ist. Diese innere Schleife macht 'ne weitere Überprüfung, ob number % (mod) 2 0 ist.

Also, es guckt, ob die Zahl gerade ist, und dann gibt's die Aussage „Die Zahl ist gerade“ aus.

Aber es gibt einen Haken: Wenn du genau hinsiehst, wirst du feststellen, dass wie im vorherigen Code auch diesmal die Anweisung number=number+1 fehlt. Da du die Variable „number“ nirgendwo erhöhst, bleibt ihr Wert immer gleich und der Code landet in einer Endlosschleife. Das heißt, wenn es mal in die Schleife reinkommt, kommt es nie wieder raus und druckt die Anweisung unendlich oft, weil die Variable number immer auf 2 gesetzt wird. Diese Zahl ist natürlich kleiner als 5 und gerade.

Schauen wir uns jetzt mal 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 angepasste Version des ersten for-Schleifen-Beispiels. Schau mal, wie eine zweite for-Schleife in der äußeren Schleife benutzt wird.

Mach weiter und führe den Code aus.

Du wirst sehen, dass die Steuerung in die erste for-Schleife geht und der Wert der Variablen number auf 0 gesetzt wird. Die erste print-Anweisung wird ausgegeben, und dann geht's weiter mit der zweiten for-Schleife, wo der Wert der Variablen another_number auf 0 gesetzt wird. Die erste print-Anweisung in der zweiten for-Schleife wird einmal ausgegeben.

Jetzt geht die Kontrolle wieder zurück zur inneren for-Schleife und der Wert von another_number wird wieder auf die nächste ganze Zahl gesetzt, bevor die Anweisung in der Funktion print() ausgegeben wird.

Der oben beschriebene Prozess läuft weiter, bis die Steuerung das Ende der Funktion range() erreicht hat, in diesem Fall 5. Dann springt die Steuerung zurück zur äußersten Schleife, setzt die Variable number auf die nächste ganze Zahl, druckt die Anweisung innerhalb der Funktion print(), geht zur inneren Schleife und wiederholt dann alle oben genannten Schritte, bis die Funktion range() durchlaufen ist.

Diese Reise der Steuerung, die von der äußersten Schleife ausgeht, die innere Schleife durchläuft und dann wieder zur äußeren for-Schleife zurückkehrt, geht weiter, bis die Steuerung den gesamten Bereich abgedeckt hat, was in deinem Fall dreimal ist.

Jetzt, wo du ein paar Erklärungen zu verschachtelten Schleifen gelesen hast, ist es Zeit, selbst loszulegen! Schreib ein Python-Programm, das das folgende Muster mit einer verschachtelten for-Schleife macht:

break und continue Stichworte: Endlose Schleifen erstellen

Du kannst break und continue in jeder Schleife verwenden, die du erstellst. Diese Schlüsselwörter sind nicht nur dazu da, um absichtlich erzeugte Endlosschleifen zu unterbrechen, aber man sollte sie trotzdem vorsichtig einsetzen. Beide Schlüsselwörter machen es anderen – und auch dir selbst in ein paar Monaten, wenn du deinen Code nochmal anschaust – schwerer, den Kontrollfluss in der Schleife und den Endpunkt der Bedingung zu verstehen. Außerdem musst du die Schlüsselwörter break und continue nicht verwenden: Wie du bisher gesehen hast, bist du auch ohne sie super zurechtgekommen!

In manchen Fällen kann es aber klarer sein, absichtlich Endlosschleifen zu schreiben, statt die üblichen for- und while-Schleifen, die du bisher gesehen hast. Klar, in solchen Fällen solltest du diese Stichwörter ruhig benutzen!

Unterbrechen und Fortsetzen von While-Schleifen in Python

Zum Glück gibt's einen Weg, aus dieser Endlosschleife rauszukommen, 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 Code oben ausführst, landet er nicht mehr in einer Endlosschleife.

„Was ist das für eine Zauberei!“, rufst du. – Ich sag dir, chill mal, das ist keine Zauberei.

Wenn das Steuerelement auf das Schlüsselwort break stößt, weiß es, dass es die Schleife (in diesem Fall die innere Schleife) verlassen und die nächste Codezeile ausführen muss. Es bricht also die innere while-Schleife ab, geht zur äußeren Schleife über und macht weiter wie gewohnt, bis die Bedingung in der äußeren while-Schleife erfüllt ist.

Du solltest bedenken, dass nach dem Schlüsselwort break eine Codezeile kommen muss, sonst funktioniert es nicht. Versuch mal, die Codezeile nach dem Schlüsselwort break im obigen Beispiel zu löschen und dann den Code auszuführen.

Was passiert, wenn du das Schlüsselwort continue nach der Anweisung break einfügst? Du kannst den folgenden Code verwenden:

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 abgeänderte Version des Beispiels für das Schlüsselwort break.

Wenn du den obigen Code ausführst, kommst du wieder in eine Endlosschleife. Bevor du dir vor Frustration die Haare raufst, schau mal genauer hin. Du wirst sehen, dass nach dem Umbruch das Schlüsselwort continue steht. Das Schlüsselwort continue sorgt dafür, dass die Kontrolle zurück an die äußerste Schleife geht, noch bevor die Variable number erhöht wird. Deshalb landet der Code in einer Endlosschleife.

Unterbrechen und Fortsetzen von For-Schleifen

Was wäre, wenn du die innere for-Schleife im obigen Beispiel nicht für den gesamten Bereich ausführen möchtest? Du kannst eine break-Anweisung ähnlich wie bei der while-Schleife verwenden.

# 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 sagt das Schlüsselwort break nach der inneren Schleife dem Programm, dass es die innere Schleife verlassen soll, und dann geht's zurück zur äußeren Schleife.

Führ 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 gemacht und die innere Schleife wird gar nicht berührt.

„Warum?“, fragst du.

Schau dir den Code genauer an. Gleich nach der zweiten print-Anweisung in der äußersten Schleife gibt's ein Schlüsselwort continue. Es sagt der Steuerung, dass sie zurück zur äußeren for-Schleife springen und von vorne anfangen soll, und deshalb kommt die Steuerung nie zur inneren Schleife.

Anders als bei der while-Schleife brauchst du in der for-Schleife keinen Code nach dem Schlüsselwort break. Eine Break-Schleife allein funktioniert in einer for-Schleife einwandfrei.

range() gegen xrange()

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

Um zu verstehen, wie diese beiden Funktionen ähnlich sind, schau dir mal das folgende Beispiel an:

# 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 Code oben ausführst, wirst du sehen, dass der Wert der Variablen number um den Faktor 2 übersprungen wird, und das liegt an den Parametern in der Funktion range().

Der erste Parameter in dieser Funktion ist der Startparameter. Das ist der Punkt, ab dem die Steuerung mit dem Zählen anfängt. Der zweite Parameter ist der Stopp-Parameter, also der Punkt, an dem die Steuerung anhalten soll, und der letzte Parameter ist die Schrittfunktion, die den Faktor festlegt, um den die Steuerung beim Zählen springen soll.

Also, im obigen Fall fängt die Steuerung bei 5 an und durchläuft dann die Schleife bis 9, wobei bei jedem Durchlauf 2 hinzugefügt wird. Das heißt 5, 5+2=7, 7+2=9.

Du hast gelernt, wie man mit der Funktion range() festlegt, wie oft dein Code durchlaufen werden soll. In Python 2.x gibt's noch 'ne andere Möglichkeit, das zu machen, und zwar mit der Funktion xrange(). Mach mal den folgenden Code:

# 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

Was für einen Unterschied hast du zwischen der Ausgabe des obigen Codes und der Ausgabe des Codes ohne die Funktion xrange() gesehen? Kein Unterschied?

Genau so ist es. Du wirst keinen Unterschied in der Ausgabe des Codes sehen.

Warum solltest du also die Funktion xrange() nutzen? Du kommst später im Tutorial dazu. Führ 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 zwischen den beiden print-Anweisungen gibt. In der print-Anweisung, die die Funktion xrange() enthält, wird das Funktionsobjekt xrange() ausgegeben. Bei der print-Anweisung mit der Funktion range() ist das anders: Da kriegst du eine Liste von ganzen Zahlen von 0 bis 9.

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 angezeigt. Wenn du aber die Funktion xrange() definierst, wird keine Liste im Speicher abgelegt. Stattdessen macht die Funktion xrange() ganze Zahlen im ganzen Bereich, wenn du sie brauchst. So hilft die Funktion xrange() dabei, Speicherplatz in Systemen mit wenig Ressourcen zu sparen.

Verbesser deine Python-Kenntnisse!

Glückwunsch, du hast es bis zum Ende dieses Tutorials geschafft. Jetzt, wo du gelernt hast, wie man Schleifen in Python benutzt, probier's doch mal aus. Je mehr du übst, desto besser!