4  Verzweigungen mit bedingten Anweisungen und Schleifen in Python

Dieses Tutorial ist das dritte einer Reihe zur Einführung in die Programmierung und Datenanalyse mit der Python-Programmiersprache. Diese Tutorials basieren auf einem praktischen, programmbasierten Ansatz. Der beste Weg, das Material zu erlernen, besteht darin, den Code auszuführen und mit den Beispielen zu experimentieren.

Die folgenden Themen werden in diesem Tutorial behandelt:

• Verzweigungen mit if, else und elif
• Iteration mit while Schleifen
• Iteration mit for Schleifen

4.1 Verzweigungen mit if, else und elif

Eine wirklich mächtige Funktion von Programmiersprachen ist Verzweigung: die Fähigkeit, Entscheidungen zu treffen und abhängig davon, ob eine oder mehrere Bedingungen wahr sind, einen anderen Satz von Anweisungen auszuführen.

4.1.1 Die if Anweisung

In Python wird die Verzweigung mit der if Anweisung durchgeführt, die folgendermaßen geschrieben wird:

if Bedingung:
    Anweisung1
    Anweisung2

Die Bedingung kann entweder eine Variable oder ein Ausdruck sein. Wenn die Bedingung zu True auswertet, dann werden die Anweisungen innerhalb des if-Blocks ausgeführt. Beachte die 4 Leerzeichen vor Anweisung1, Anweisung2 usw. Die Leerzeichen informieren Python, dass diese Anweisungen mit der darüber liegenden if Anweisung in Verbindung stehen. Diese Technik, den Code durch Hinzufügen von Leerzeichen zu strukturieren, wird Einrückung genannt.

Einrückung: Python stützt sich stark auf Einrückungen (indentation) (Leerraum vor einer Anweisung) um die Struktur im Code zu definieren. Das macht den Python-Code leicht zu lesen und zu verstehen, aber du kannst auf Probleme stoßen, wenn du die Einrückung nicht richtig verwendest. Rücke deinen Code ein, indem du den Cursor am Anfang der Zeile platzierst und einmal die Tab Taste drückst, um 4 Leerzeichen hinzuzufügen. Wenn du Tab noch einmal drückst, wird der Code um weitere 4 Leerzeichen eingerückt, und durch Drücken von Shift+Tab wird die Einrückung um 4 Leerzeichen reduziert.

Als Beispiel schreiben wir einen Code, um eine Nachricht auszugeben, wenn eine gegebene Zahl gerade ist.

a_number = 34

if a_number % 2 == 0:
    print("We're inside an if block")
    print('The given number {} is even.'.format(a_number))

We're inside an if block
The given number 34 is even.

Beachte, dass wir den Modulus-Operator % verwenden, um den Rest der Division von a_number durch 2 zu finden, und dann den Vergleichsoperator == verwenden, um zu überprüfen, ob der Rest 0 ist, was darauf hinweist, dass die Zahl durch 2 teilbar ist, also gerade ist.

Da die Zahl 34 tatsächlich durch 2 teilbar ist, ergibt der Ausdruck a_number % 2 == 0 den Wert True, sodass die print Anweisung unter der if Anweisung ausgeführt wird. Beachte auch, dass wir die String format Methode verwenden, um die Zahl in die Nachricht einzufügen.

Versuchen wir das oben Gesagte erneut mit einer ungeraden Zahl.

another_number = 33

if another_number % 2 == 0:
    print('The given number {} is even.'.format(a_number))

Da die Bedingung another_number % 2 == 0 erwartungsgemäß False ergibt, wird keine Meldung ausgegeben.

4.1.2 Die else Anweisung

Wenn die Zahl im obigen Beispiel nicht gerade ist, möchten wir ebenfalls eine Meldung ausgeben. Dies kann durch Hinzufügen der else-Anweisung erfolgen.

if condition:
    statement1
    statement2
else:
    statement4
    statement5

Wenn die Bedingung True ergibt, werden die Anweisungen im if-Block ausgeführt, und wenn sie False ergibt, werden die Anweisungen im else-Block ausgeführt.

a_number = 34

if a_number % 2 == 0:
    print('The given number {} is even.'.format(a_number))
else:
    print('The given number {} is odd.'.format(a_number))

The given number 34 is even.

another_number = 33

if another_number % 2 == 0:
    print('The given number {} is even.'.format(another_number))
else:
    print('The given number {} is odd.'.format(another_number))

The given number 33 is odd.

Hier ist ein weiteres Beispiel, das den in-Operator verwendet, um die Existenz innerhalb eines Tupels zu überprüfen.

the_3_musketeers = ('Athos', 'Porthos', 'Aramis')

a_candidate = "D'Artagnan"

if a_candidate in the_3_musketeers:
    print("{} is a musketeer".format(a_candidate))
else:
    print("{} is not a musketeer".format(a_candidate))

D'Artagnan is not a musketeer

4.1.3 Die elif Anweisung

Python bietet auch eine elif Anweisung (kurz für “else if”), um eine Reihe von bedingten Blöcken zu verketten. Die Bedingungen werden nacheinander ausgewertet. Für die erste Bedingung, die True ergibt, werden die Anweisungen im jeweiligen Block ausgeführt und die restlichen Bedingungen werden nicht ausgewertet. So wird in einer Kette von if, elif, elif… Anweisungen genau ein bedingter Block ausgewertet.

today = 'Wednesday'

if today == 'Sunday':
    print("Today is the day of the sun.")
elif today == 'Monday':
    print("Today is the day of the moon.")
elif today == 'Tuesday':
    print("Today is the day of Tyr, the god of war.")
elif today == 'Wednesday':
    print("Today is the day of Odin, the supreme diety.")
elif today == 'Thursday':
    print("Today is the day of Thor, the god of thunder.")
elif today == 'Friday':
    print("Today is the day of Frigga, the goddess of beauty.")
elif today == 'Saturday':
    print("Today is the day of Saturn, the god of fun and feasting.")

Today is the day of Odin, the supreme diety.

Im obigen Beispiel werden die ersten drei Bedingungen als False ausgewertet, sodass keine der ersten drei Nachrichten ausgegeben wird. Die vierte Bedingung wird mit True ausgewertet, sodass die entsprechende Meldung ausgegeben wird. Die übrigen Bedingungen werden übersprungen. Versuchen Sie, den Wert von today oben zu ändern und die Zellen erneut auszuführen, um alle verschiedenen Nachrichten zu auszugeben.

Um zu überprüfen, ob die übrigen Bedingungen übersprungen werden, versuchen wir es mit einem anderen Beispiel.

a_number = 15

if a_number % 2 == 0:
    print('{} is divisible by 2'.format(a_number))
elif a_number % 3 == 0:
    print('{} is divisible by 3'.format(a_number))
elif a_number % 5 == 0:
    print('{} is divisible by 5'.format(a_number))
elif a_number % 7 == 0:
    print('{} is divisible by 7'.format(a_number))

15 is divisible by 3

Beachten Sie, dass die Nachricht 15 is divisible by 5 nicht ausgegeben wird, weil die Bedingung a_number % 5 == 0 nicht ausgewertet wird, da die vorherige Bedingung a_number % 3 == 0 zu True auswertet. Dies ist der entscheidende Unterschied zwischen einer Kette von if, elif, elif… Anweisungen und einfach einer Kette von if Anweisungen, bei denen jede Bedingung unabhängig ausgewertet wird.

if a_number % 2 == 0:
    print('{} is divisible by 2'.format(a_number))
if a_number % 3 == 0:
    print('{} is divisible by 3'.format(a_number))
if a_number % 5 == 0:
    print('{} is divisible by 5'.format(a_number))
if a_number % 7 == 0:
    print('{} is divisible by 7'.format(a_number))

15 is divisible by 3
15 is divisible by 5

4.1.4 Gemeinsame Verwendung von if, elif und else.

Sie können auch eine else-Anweisung am Ende einer Kette von if, elif…-Anweisungen einfügen. Dieser Code im else-Block wird ausgewertet, wenn keine der Bedingungen zutrifft.

a_number = 49

if a_number % 2 == 0:
    print('{} is divisible by 2'.format(a_number))
elif a_number % 3 == 0:
    print('{} is divisible by 3'.format(a_number))
elif a_number % 5 == 0:
    print('{} is divisible by 5'.format(a_number))
else:
    print('All checks failed!')
    print('{} is not divisible by 2, 3 or 5'.format(a_number))

All checks failed!
49 is not divisible by 2, 3 or 5

Bedingungen können auch mit den logischen Operatoren and, or und not kombiniert werden.

a_number = 15

if a_number % 3 == 0 and a_number % 5 == 0:
    print("The number {} is divisible by 3 and 5".format(a_number))
elif not a_number % 5 == 0:
    print("The number {} is not divisible by 5".format(a_number))

The number 15 is divisible by 3 and 5

4.1.5 Nicht-Boolesche Bedingungen

Beachten Sie, dass Bedingungen nicht unbedingt boolesche Werte sein müssen. Tatsächlich kann eine Bedingung einen beliebigen Wert haben. Der Wert wird mithilfe des bool Operators automatisch in einen booleschen Wert umgewandelt. Das bedeutet, dass falsche Werte wie 0, '', {}, [] usw. als False und alle anderen Werte als True ausgewertet werden.

if '':
    print('The condition evaluted to True')
else:
    print('The condition evaluted to False')

The condition evaluted to False

if 'Hello':
    print('The condition evaluted to True')
else:
    print('The condition evaluted to False')

The condition evaluted to True

if { 'a': 34 }:
    print('The condition evaluted to True')
else:
    print('The condition evaluted to False')

The condition evaluted to True

if None:
    print('The condition evaluted to True')
else:
    print('The condition evaluted to False')

The condition evaluted to False

4.1.6 Verschachtelte bedingte Anweisungen

Der Code in einem if-Block kann auch eine if Anweisung enthalten. Dieses Muster wird Verschachtelung (nesting) genannt und wird verwendet, wenn Sie nach einer anderen Bedingung suchen müssen, nachdem eine bestimmte Bedingung als wahr bewertet wurde.

a_number = 15

if a_number % 2 == 0:
    print("{} is even".format(a_number))
    if a_number % 3 == 0:
        print("{} is also divisible by 3".format(a_number))
    else:
        print("{} is not divisibule by 3".format(a_number))
else:
    print("{} is odd".format(a_number))
    if a_number % 5 == 0:
        print("{} is also divisible by 5".format(a_number))
    else:
        print("{} is not divisibule by 5".format(a_number))

15 is odd
15 is also divisible by 5

Beachten Sie, dass die print Anweisungen um 8 Leerzeichen eingerückt sind, um anzuzeigen, dass sie Teil der inneren if/else Blöcke sind.

Verschachtelte if- und else-Anweisungen sind oft verwirrend zu lesen und anfällig für menschliches Versagen. Es empfiehlt sich, die Verschachtelung nach Möglichkeit zu vermeiden oder die Verschachtelung auf 1 oder 2 Ebenen zu beschränken.

4.1.7 Abkürzung für den bedingten Ausdruck if

Ein häufiger Anwendungsfall der if-Anweisung besteht darin, eine Bedingung zu testen und den Wert einer Variablen basierend auf der Bedingung festzulegen.

a_number = 13

if a_number % 2 == 0:
    parity = 'even'
else:
    parity = 'odd'

print('The number {} is {}.'.format(a_number, parity))

The number 13 is odd.

Python bietet eine kürzere Syntax, die das Schreiben solcher Bedingungen in einer einzigen Codezeile ermöglicht. Es ist als bedingter Ausdruck bekannt, manchmal auch als ternärer Operator. Es hat die folgende Syntax:

x = true_value if condition else false_value

Es hat das gleiche Verhalten wie der folgende if-else-Block:

if condition:
    x = true_value
else:
    x = false_value

Probieren wir es am Beispiel oben aus.

parity = 'even' if a_number % 2 == 0 else 'odd'

print('The number {} is {}.'.format(a_number, parity))

The number 13 is odd.

4.1.8 Anweisungen und Ausdrücke

Der bedingte Ausdruck unterstreicht eine wichtige Unterscheidung zwischen Anweisungen und Ausdrücken in Python.

Anweisungen: Eine Anweisung (statement) ist eine ausführbare Anweisung. Jede Zeile Code, die wir bisher geschrieben haben, ist eine Anweisung, z. B. das Zuweisen einer Variable, das Aufrufen einer Funktion, bedingte Anweisungen mit if, else und elif, Schleifen mit for und while usw.

Ausdrücke: Ein Ausdruck (expression) ist ein Code, der zu einem Wert ausgewertet wird. Beispiele sind Werte verschiedener Datentypen, arithmetische Ausdrücke, Bedingungen, Variablen, Funktionsaufrufe, bedingte Ausdrücke usw.

Die meisten Ausdrücke können als Anweisungen ausgeführt werden, aber nicht alle Anweisungen sind Ausdrücke. Zum Beispiel ist die if-Anweisung kein Ausdruck, da sie nicht zu einem Wert ausgewertet wird, sie führt einfach nur eine Verzweigung im Code aus. Ähnlich verhält es sich mit Schleifen und Funktionsdefinitionen, die keine Ausdrücke sind (wir werden in späteren Abschnitten mehr darüber lernen).

Als Faustregel gilt: Ein Ausdruck ist alles, was auf der rechten Seite des Zuweisungsoperators = erscheinen kann. Sie können dies als Test verwenden, um zu überprüfen, ob etwas ein Ausdruck ist oder nicht. Sie erhalten einen Syntaxfehler, wenn Sie versuchen, etwas zuzuweisen, das kein Ausdruck ist.

# if statement
result = if a_number % 2 == 0: 
    'even'
else:
    'odd'

  Cell In[30], line 2
    result = if a_number % 2 == 0:
             ^
SyntaxError: invalid syntax

# if expression
result = 'even' if a_number % 2 == 0 else 'odd'

4.1.9 Die pass Anweisung

if Anweisungen können nicht leer sein, es muss mindestens eine Anweisung in jedem if und elif Block geben. Sie können die pass Anweisung verwenden, um nichts zu tun und einen Fehler zu vermeiden.

a_number = 9

if a_number % 2 == 0:
elif a_number % 3 == 0:
    print('{} is divisible by 3 but not divisible by 2')

  Cell In[33], line 2
    elif a_number % 3 == 0:
    ^
IndentationError: expected an indented block after 'if' statement on line 1

if a_number % 2 == 0:
    pass
elif a_number % 3 == 0:
    print('{} is divisible by 3 but not divisible by 2'.format(a_number))

9 is divisible by 3 but not divisible by 2

4.2 Iteration mit while Schleifen

4.2.1 Grundlagen

Eine weitere leistungsstarke Funktion von Programmiersprachen, die eng mit Verzweigungen verbunden ist, ist die Fähigkeit, eine oder mehrere Anweisungen mehrmals auszuführen. Diese Funktion wird oft als Iteration oder Schleifenbildung bezeichnet, und es gibt zwei Möglichkeiten, dies in Python zu tun: Mit while Schleifen und for Schleifen.

while Schleifen haben die folgende Syntax:

while Bedingung:
    Anweisung(en)

Die Anweisungen im Block unter while werden wiederholt ausgeführt, solange die Bedingung zu True ausgewertet wird. In den meisten Fällen bewirkt der Block von Anweisungen eine Änderung einer Variablen, die dazu führt, dass die Bedingung nach einer bestimmten Anzahl von Iterationen zu False ausgewertet wird.

Versuchen wir als Beispiel, die Fakultät von 100 mit einer while Schleife zu berechnen. Die Fakultät einer Zahl n ist definiert als das Produkt oder die Multiplikation aller Zahlen von 1 bis n, also 1*2*3*...*(n-2)*(n-1)*n.

result = 1
i = 1

while i <= 100:
    result = result * i
    i = i+1

print('The factorial of 100 is: {}'.format(result))

The factorial of 100 is: 93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

So funktioniert der obige Code:

• Wir initialisieren zwei Variablen result und i. result enthält das endgültige Ergebnis der Berechnung. Und i wird verwendet, um die nächste zu result zu multiplizierende Zahl zu verfolgen. Beide werden auf 1 initialisiert (können Sie erklären warum?)

• Die Bedingung i<=100 gilt als wahr (da i zunächst 1 ist), daher werden die Anweisungen im Block unter while ausgeführt.

• Das result wird auf result * i aktualisiert, und i wird um 1 erhöht und hat nun den Wert 2.

• An diesem Punkt wird die Bedingung i<=100 erneut ausgeführt, und da sie weiterhin als wahr gilt, wird das result erneut auf result * i aktualisiert und i wird auf 3 erhöht.

• Dieser Prozess wird wiederholt, bis die Bedingung falsch wird, was passiert, wenn i den Wert 101 hat. Sobald die Bedingung zu False ausgewertet wird, endet die Ausführung der Schleife und die darunter liegende print Anweisung wird ausgeführt.

Können Sie sehen, warum result am Ende der Schleife den Wert der Fakultät von 100 hat? Wenn nicht, versuchen Sie, print Anweisungen innerhalb der Schleife hinzuzufügen, um die Werte von result und i am Ende jeder Schleife auszugeben.

Iteration ist eine wirklich mächtige Technik, denn sie gibt Computern einen großen Vorteil gegenüber Menschen, wenn es darum geht, Hunderte oder Millionen von wiederholten Operationen sehr schnell auszuführen. Mit nur 4-5 Zeilen Code konnten wir fast sofort 100 Zahlen multiplizieren. Was noch interessanter ist, ist, dass der gleiche Code verwendet werden kann, um tausend Zahlen zu multiplizieren (ändern Sie einfach die Bedingung auf i <= 1000) in nur wenigen Sekunden.

Sie können überprüfen, wie lange eine Zelle zur Ausführung braucht, indem Sie den speziellen magic Befehl %%time an den Anfang einer Zelle setzen. Versuchen Sie zu überprüfen, wie lange es dauert, die Fakultät von 100, 1000, 10000, 100000 usw. zu berechnen.

%%time

result = 1
i = 1

while i <= 1000:
    result *= i # same as result = result * i
    i += 1 # same as i = i+1

print(result)

402387260077093773543702433923003985719374864210714632543799910429938512398629020592044208486969404800479988610197196058631666872994808558901323829669944590997424504087073759918823627727188732519779505950995276120874975462497043601418278094646496291056393887437886487337119181045825783647849977012476632889835955735432513185323958463075557409114262417474349347553428646576611667797396668820291207379143853719588249808126867838374559731746136085379534524221586593201928090878297308431392844403281231558611036976801357304216168747609675871348312025478589320767169132448426236131412508780208000261683151027341827977704784635868170164365024153691398281264810213092761244896359928705114964975419909342221566832572080821333186116811553615836546984046708975602900950537616475847728421889679646244945160765353408198901385442487984959953319101723355556602139450399736280750137837615307127761926849034352625200015888535147331611702103968175921510907788019393178114194545257223865541461062892187960223838971476088506276862967146674697562911234082439208160153780889893964518263243671616762179168909779911903754031274622289988005195444414282012187361745992642956581746628302955570299024324153181617210465832036786906117260158783520751516284225540265170483304226143974286933061690897968482590125458327168226458066526769958652682272807075781391858178889652208164348344825993266043367660176999612831860788386150279465955131156552036093988180612138558600301435694527224206344631797460594682573103790084024432438465657245014402821885252470935190620929023136493273497565513958720559654228749774011413346962715422845862377387538230483865688976461927383814900140767310446640259899490222221765904339901886018566526485061799702356193897017860040811889729918311021171229845901641921068884387121855646124960798722908519296819372388642614839657382291123125024186649353143970137428531926649875337218940694281434118520158014123344828015051399694290153483077644569099073152433278288269864602789864321139083506217095002597389863554277196742822248757586765752344220207573630569498825087968928162753848863396909959826280956121450994871701244516461260379029309120889086942028510640182154399457156805941872748998094254742173582401063677404595741785160829230135358081840096996372524230560855903700624271243416909004153690105933983835777939410970027753472000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
CPU times: user 956 µs, sys: 82 µs, total: 1.04 ms
Wall time: 1.06 ms

Hier ist ein weiteres Beispiel, das zwei while-Schleifen verwendet, um ein interessantes Muster zu erstellen.

line = '*'
max_length = 10

while len(line) <= max_length:
    print(line)
    line += "*"
    
while len(line) > 0:
    print(line)
    line = line[:-1]

*
**
***
****
*****
******
*******
********
*********
**********
***********
**********
*********
********
*******
******
*****
****
***
**
*

4.2.2 Endlosschleifen

Wenn die Bedingung in einer while-Schleife immer wahr ist, führt Python den Code innerhalb der Schleife immer wieder aus und die Ausführung des Codes wird nie abgeschlossen. Diese Situation wird als Endlosschleife bezeichnet und weist im Allgemeinen darauf hin, dass Sie einen Fehler in Ihrem Code gemacht haben, z. B. Verwenden der falschen Bedingung oder Vergessen, eine Variable mit einer Schleife zu aktualisieren, wodurch die Bedingung letztendlich falsch wird.

Wenn Ihr Code während der Ausführung in einer Endlosschleife stecken bleibt, klicken Sie einfach auf die Schaltfläche Stop in der Symbolleiste (neben Run) oder wählen Sie Kernel > Interrupt aus der Jupyter-Menüleiste, um die Ausführung zu stoppen bzw unterbricht die Ausführung des Codes. Die nächsten beiden Zellen führen beide zu Endlosschleifen und müssen unterbrochen werden.

# INFINITE LOOP - INTERRUPT THIS CELL

result = 1
i = 1

while i <= 100:
    result = result * i
    # forgot to increment i

---------------------------------------------------------------------------
KeyboardInterrupt                         Traceback (most recent call last)
Cell In[38], line 6
      3 result = 1
      4 i = 1
----> 6 while i <= 100:
      7     result = result * i

KeyboardInterrupt: 

# INFINITE LOOP - INTERRUPT THIS CELL

result = 1
i = 1

while i > 0 : # wrong condition
    result *= i
    i += 1

4.2.3 break- und continue-Anweisungen

Sie können die break-Anweisung im Hauptteil der Schleife verwenden, um die Ausführung sofort zu stoppen und die Schleife zu break zu verlassen (auch wenn die für while angegebene Bedingung immer noch wahr ist).

i = 1
result = 1

while i <= 100:
    result *= i
    if i == 42:
        print('Magic number 42 reached! Stopping execution..')
        break
    i += 1
    
print('i:', i)
print('result:', result)

Magic number 42 reached! Stopping execution..
i: 42
result: 1405006117752879898543142606244511569936384000000000

Wie Sie oben sehen können, beträgt der Wert von i am Ende der Ausführung 42. Dieses Beispiel zeigt auch, wie Sie eine if-Anweisung innerhalb einer while-Schleife verwenden können.

Manchmal möchten Sie vielleicht nicht die gesamte Schleife beenden, sondern einfach die verbleibenden Anweisungen in der Schleife überspringen und weiter zur nächsten Schleife gehen. Dies können Sie mit der continue-Anweisung erreichen.

i = 1
result = 1

while i < 20:
    i += 1
    if i % 2 == 0:
        print('Skipping {}'.format(i))
        continue
    print('Multiplying with {}'.format(i))
    result = result * i
    
print('i:', i)
print('result:', result)

Skipping 2
Multiplying with 3
Skipping 4
Multiplying with 5
Skipping 6
Multiplying with 7
Skipping 8
Multiplying with 9
Skipping 10
Multiplying with 11
Skipping 12
Multiplying with 13
Skipping 14
Multiplying with 15
Skipping 16
Multiplying with 17
Skipping 18
Multiplying with 19
Skipping 20
i: 20
result: 654729075

Im obigen Beispiel wird die letzte Anweisung der Schleife result = result * i übersprungen, wenn i gerade ist, wie durch die während der Ausführung ausgegebenen Meldungen angezeigt.

Logging: Der Vorgang des Hinzufügens von print-Anweisungen an verschiedenen Punkten im Code (oft innerhalb von Schleifen und bedingten Anweisungen) zur Überprüfung der Werte von Variablen in verschiedenen Ausführungsstadien wird als Logging bezeichnet. Da unsere Programme mit zunehmender Komplexität naturgemäß anfällig für menschliche Fehler werden, kann Logging dabei helfen, zu überprüfen, ob das Programm wie erwartet funktioniert. In vielen Fällen werden print-Anweisungen hinzugefügt, während Code geschrieben und getestet wird, und am Ende wieder entfernt.

4.3 Iteration mit for Schleifen

4.3.1 Grundlagen

Ein for-Loop wird zum Iterieren oder Schleifen über Sequenzen verwendet, d.h. Listen, Tupel, Wörterbücher, Strings und Ranges. For-Schleifen haben die folgende Syntax:

for value in sequence:
    statement(s)

Die Anweisungen innerhalb der Schleife werden einmal für jedes Element in Sequenz ausgeführt. Hier ist ein Beispiel, das alle Elemente einer Liste ausgibt.

days = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

for day in days:
    print(day)

Monday
Tuesday
Wednesday
Thursday
Friday

Versuchen wir, for Schleifen mit einigen anderen Datentypen zu verwenden.

# Looping over a string
for char in 'Monday':
    print(char)

M
o
n
d
a
y

# Looping over a tuple
for fruit in ['Apple', 'Banana', 'Guava']:
    print("Here's a fruit:", fruit)

Here's a fruit: Apple
Here's a fruit: Banana
Here's a fruit: Guava

# Looping over a dictionary
person = {
    'name': 'John Doe',
    'sex': 'Male',
    'age': 32,
    'married': True
}

for key in person:
    print("Key:", key, ",", "Value:", person[key])

Key: name , Value: John Doe
Key: sex , Value: Male
Key: age , Value: 32
Key: married , Value: True

Beachten Sie, dass bei der Verwendung eines Dictionaries mit einer for-Schleife die Iteration über Schlüssel(keys) im Dictionary erfolgt. Der Schlüssel kann innerhalb der Schleife verwendet werden, um auf den Wert zuzugreifen. Sie können auch direkt über die Werte mit der .values Methode des Dictionaries iterieren, oder über Schlüssel-Wert-Paare mit der .items Methode.

for value in person.values():
    print(value)

John Doe
Male
32
True

for key_value_pair in person.items():
    print(key_value_pair)

('name', 'John Doe')
('sex', 'Male')
('age', 32)
('married', True)

Da es sich bei einem Schlüssel-Wert-Paar um ein Tupel handelt, können wir Schlüssel und Wert auch in separate Variablen extrahieren.

for key, value in person.items():
    print("Key:", key, ",", "Value:", value)

Key: name , Value: John Doe
Key: sex , Value: Male
Key: age , Value: 32
Key: married , Value: True

4.3.2 Iterieren mit range und enumerate.

Die range Funktion wird verwendet, um eine Sequenz von Zahlen zu erzeugen, über die mit einer for-Schleife iteriert werden kann. Sie kann auf 3 Arten verwendet werden:

• range(n) - Erstellt eine Sequenz von Zahlen von 0 bis n-1
• range(a, b) - Erstellt eine Sequenz von Zahlen von a bis b-1
• range(a, b, step) - Erstellt eine Sequenz von Zahlen von a bis b-1 mit Schritten von step

Lassen Sie es uns ausprobieren.

for i in range(7):
    print(i)

0
1
2
3
4
5
6

for i in range(3, 10):
    print(i)

3
4
5
6
7
8
9

Um Inkremente einer bestimmten Länge durchzuführen, verwenden Sie das dritte Argument in range(), z. B. range(3, 14, 4). Dies führt zu einer Schleife von 3 bis 13 in Schritten von 4

for i in range(3, 14, 4): 
    print(i)

3
7
11

Bereiche werden für die Iteration über Listen verwendet, wenn Sie während der Iteration den Index von Elementen verfolgen müssen.

a_list = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

for i in range(len(a_list)):
    print('The value at position {} is {}.'.format(i, a_list[i]))

The value at position 0 is Monday.
The value at position 1 is Tuesday.
The value at position 2 is Wednesday.
The value at position 3 is Thursday.
The value at position 4 is Friday.

Eine andere Möglichkeit, das gleiche Ergebnis wie oben zu erzielen, ist die Verwendung der Funktion enumerate mit a_list als Eingabe, die ein Tupel zurückgibt, das den Index und das entsprechende Element enthält.

for i, val in enumerate(a_list):
    print('The value at position {} is {}.'.format(i, val))

The value at position 0 is Monday.
The value at position 1 is Tuesday.
The value at position 2 is Wednesday.
The value at position 3 is Thursday.
The value at position 4 is Friday.

4.3.3 break-, continue- und pass-Anweisungen

Ähnlich wie while-Schleifen unterstützen for-Schleifen auch die Anweisung break, um aus der Schleife auszubrechen, und continue, um zur nächsten Iteration zu springen.

weekdays = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']

for day in weekdays:
    print('Today is {}'.format(day))
    if (day == 'Wednesday'):
        print("I don't work beyond Wednesday!")
        break

Today is Monday
Today is Tuesday
Today is Wednesday
I don't work beyond Wednesday!

for day in weekdays:
    if (day == 'Wednesday'):
        print("I don't work on Wednesday!")
        continue
    print('Today is {}'.format(day))

Today is Monday
Today is Tuesday
I don't work on Wednesday!
Today is Thursday
Today is Friday

Ähnlich wie if-Anweisungen dürfen for-Schleifen nicht leer sein. Sie können also eine pass-Anweisung verwenden, falls Sie keine Anweisungen innerhalb der Schleife ausführen möchten.

for day in weekdays:
    pass

4.3.4 Verschachtelte for- und while-Schleifen

Ähnlich wie bedingte Anweisungen können Schleifen in anderen Schleifen verschachtelt werden. Dies ist nützlich, um jedes Element in einer Liste von Listen, einer Liste von Wörterbüchern usw. zu durchlaufen.

persons = [{'name': 'John', 'sex': 'Male'}, {'name': 'Jane', 'sex': 'Female'}]

for person in persons:
    for key in person:
        print(key, ":", person[key])
    print(" ")

name : John
sex : Male
 
name : Jane
sex : Female
 

days = ['Monday', 'Tuesday', 'Wednesday']
fruits = ['apple', 'banana', 'guava']

for day in days:
    for fruit in fruits:
        print(day, fruit)

Monday apple
Monday banana
Monday guava
Tuesday apple
Tuesday banana
Tuesday guava
Wednesday apple
Wednesday banana
Wednesday guava

4.4 Weiterführende Literatur und Referenzen

Im Folgenden finden Sie einige Ressourcen, um mehr über bedingte Anweisungen und Schleifen in Python zu erfahren:

• Python-Tutorial bei W3Schools
• Praktische Python-Programmierung
• Offizielle Python-Dokumentation