In Python gibt es verschiedene Methoden, um Algorithmen zu bauen und komplexeste Logiken unter Verwendung von bedingte Anweisungen abzubilden. Eine der grundlegendsten Bausteine ist die Python if-Schleife, die es ermöglicht „Wenn-Dann Bedingungen“ zu prüfen und abhängig von der Unterscheidung unterschiedliche Codeblöcke auszuführen. In diesem Artikel werden die Grundlagen von Python if-Schleifen erläutert und verschiedene Beispiele gezeigt, wie diese in der Realität genutzt werden können. 

Was ist eine if-Schleife?

Die if-Schleife ist eine sogenannte Kontrollstruktur, die in den verschiedensten Programmiersprachen genutzt wird, um Codeblöcke basierend auf Bedingungen auszuführen. Sie ermöglicht es den Programmierenden Entscheidungen zu treffen und den Codefluss anhand der Entscheidungen anzupassen. 

Durch diese Funktionalität können verschiedene Pfade in einem Programm vorgesehen werden, die dynamisch aufgrund von Inputparametern durchlaufen werden. Dies ermöglicht die Abbildung von komplexen Logiken und einer besseren Nutzererfahrung. 

Im Vergleich zu anderen Kontrollstrukturen liegt der Hauptunterschied zur Python if-Anweisung darin, dass sie von Bedingungen geführt wird. Andere Kontrollstrukturen, wie beispielsweise Schleifen, hingegen wiederholen Code und stoppen, wenn eine bestimmte Bedingung erfüllt ist. Die if-Schleife hingegen bestimmt nicht über die Anzahl der Ausführungen, sondern legt lediglich fest, ob ein Codeblock ausgeführt wird oder nicht. 

Wie ist die Syntax der Python if-Schleife?

Die Syntax der Python if-Schleife ist in der Grundform relativ einfach und kann jedoch im Einzelfall deutlich komplexer werden, wenn es sich um verschachtelte Bedingungen handelt. Die grundlegende Syntax sieht wie folgt aus: 

• If: Das Schlüsselwort “if” leitet die Schleife ein und zeigt an, dass nachfolgend eine Bedingung definiert wird. 
• Bedingung: Die Bedingung wird geprüft und kann entweder wahr oder falsch zurückgeben. Gegeben dem Fall, dass die Bedingung wahr ist, wird der nachfolgende Codeblock ausgeführt. Der abschließende Doppelpunkt zeigt das Ende der Bedingung an. 
• Einrückung & Codeblock: Nach dem Doppelpunkt folgt eine Einrückung, die definiert, wie lange der Codeblock ist, der bei einer wahren Bedingung ausgeführt oder bei einer falschen Bedingung übersprungen wird. Jede eingerückte Zeile ist Teil dieses Codeblocks. Die erste Zeile, die nicht mehr eingerückt ist, gehört nicht mehr zur if-Schleife und wird in jedem Fall ausgeführt. 

In einem einfachen Beispiel kann man mithilfe einer Python if-Schleife prüfen, ob eine Zeile größer fünf ist und wenn dies zutrifft, eine Nachricht ausgeben. Dazu wird nach dem if-Statement die Bedingung definiert, die prüft, ob eine Zahl größer fünf ist:  

Nur wenn die angegebene Zahl tatsächlich größer als fünf ist, wird das print-Statement ausgeführt, ansonsten wird der Block übersprungen und das Programm hat keinerlei Ausgabe. 

Welche Vergleichsoperatoren können in einer Python if-Schleife verwendet werden?

Die Fülle an Vergleichsoperatoren, die in der if-Schleife genutzt werden können, ist groß und macht es deshalb zu einem vielseitigen Werkzeug für die verschiedensten Anwendungen. 

In einer if-Schleife können die folgenden Vergleichsoperatoren genutzt werden: 

• Gleichheit („==“):

• Ungleichheit („!=“):

• Größer als („>“):

• Kleiner als („<“):

• Größer oder gleich („>=“):

• Kleiner oder gleich („<=“):

Mithilfe von diesen Vergleichsoperatoren lassen sich bereits viele Bedingungen prüfen. Die Individualisierbarkeit steigt jedoch noch weiter an, wenn man mehrere Bedingungen mit sogenannten logischen Operatoren verknüpft. Es können beispielsweise mehrere Teilbedingungen mit einem „und“ oder einem „oder“ verknüpft werden. 

Die folgenden logischen Operatoren können verwendet werden:

• Und-Operator (and): Gibt True zurück, wenn beide Operanden True sind, andernfalls False.
• Oder-Operator (or): Gibt Wahr zurück, wenn mindestens einer der Operanden Wahr ist, andernfalls Falsch.
• Not-Operator (not): Negiert den booleschen Wert, d. h. gibt True zurück, wenn der Operand False ist, und umgekehrt.

Hier sind ein paar Beispiele zur Nutzung dieser Operatoren:

Der letzte logische Operator ist die Verneinung, die den Wahrheitsgehalt einer Aussage in das Gegenteil umkehrt und in Python durch das Stichwort „not“ gekennzeichnet ist. Eine wahre Bedingung wird durch „not“ also zu einer falschen Aussage und umgekehrt.

Wie werden else und elif verwendet werden?

Neben der einfachen Anwendung von Python if-Schleifen, wie wir sie bisher kennengelernt haben, gibt es auch weitere Zusätze, die eine erweiterte Kontrolle über den Programmfluss ermöglichen. 

Mithilfe von „else“ lässt sich ein Codeblock definieren, der ausgeführt wird, wenn die Bedingung aus der Python if-Schleife falsch ist. Sie wird immer direkt nach dem Codeblock der if-Schleife ohne Einrückung verwendet. Wenn die Python if-Schleife jedoch wahr ist wird der Code aus dem else-Block einfach übersprungen und die Codezeilen danach als nächstes ausgeführt. 

Dieser einfache Zusatz ermöglicht es, den gegenteiligen Fall gesondert abzufangen und zu behandeln. Jedoch ist der else-Block nicht erforderlich bei der Definition einer Python if-Schleife und muss nur hinzugefügt werden, wenn der gegenteilige Fall behandelt werden soll. 

Eine weitere Möglichkeit ist die Nutzung des sogenannten „elif“-Block. Dies ist die Abkürzung für „else if“ und wird genutzt, um eine weitere Bedingung zu prüfen, falls die erste Bedingung falsch ist. Der else-Block kann auch zusammen mit if und elif verwendet werden und wird nur dann ausgeführt, wenn sowohl die Bedingungen aus dem if-Block als auch die Bedingung aus dem elif-Bock falsch ist. 

An sich gibt es keine Begrenzung der möglichen elif-Blöcke und dadurch kann es dafür genutzt werden, mehrere Bedingungen nacheinander abzufragen. Hierbei ist es jedoch wichtig zu beachten, dass die Reihenfolge der Definition eine wichtige Rolle spielt, denn sobald die erste Bedingung erfüllt ist, werden die nachfolgenden Blöcke nicht mehr ausgeführt. 

Mithilfe von diesen zusätzlichen Blöcken lassen sich verschiedene Verzweigungen innerhalb der if-Schleifen bilden und dadurch deutlich komplexere Bedingungen ausführen. Jedoch muss mit deren Nutzung vorsichtig sein, da sie ein Programm unnötig komplex machen können, was sich wiederum negativ auf die Performance auswirkt. 

Was sind verschachtelte if-Anweisungen?

Mithilfe von verschachtelten if-Anweisungen können auch komplexere Algorithmen erstellt werden. Dazu wird in der Einrückung einer ersten if-Schleife, eine neue definiert. Mithilfe von dieser Technik können mehrere Bedingungen nacheinander geprüft werden und abhängig von dieser Prüfung unterschiedliche Codeblöcke ausgeführt werden.

Die allgemeine Syntax einer verschachtelten if-Anweisung stellt sich wie folgt dar:

Konkret kann das dann folgendermaßen aussehen:

In diesem Code wird als erstes die äußerste Anweisung geprüft, also ob die Zahl in der Variable x größer als fünf ist. Wenn diese Bedingung zutrifft, wird das print-Statement ausgeführt und anschließend die nächste if-Schleifen durchlaufen, die wiederum prüft, ob die Variable y größer als drei ist.

In der Theorie sind unendlich viele Verschachtelungsebenen möglich. Diese führen jedoch zu einer schlechteren Verständlichkeit des Codes. Außerdem lassen sich viele Verschachtelungen auch durch logische Operatoren vermeiden.

Welche häufigen Fehler passieren bei der Arbeit mit Python if-Schleifen?

Die Nutzung der Python if-Schleife ist grundlegend relativ einfach und kann jedoch mit den zusätzlichen „elif“ und „else“ Blöcken durchaus schnell komplex werden. Um einen einwandfreien Ablauf des Programms sicherzustellen, sollte man sicherstellen, dass die folgenden Fehler auf jeden Fall nicht begangen wurden: 

1. Fehlende Einrückung: Es muss sichergestellt sein, dass der Codeblock nach der if-Bedingung durch eine Einrückung von der vorherigen Zeile abgetrennt ist. Ansonsten erkennt Python die Schleife nicht. 
2. Vergessene Doppelpunkte: Die Bedingung muss immer mit einem Doppelpunkt abgeschlossen werden. Ansonsten wirft Python einen Syntaxfehler. 
3. Zuweisung statt Vergleichsoperator: Bei der Nutzung des Vergleichsoperators „==“, um einen Vergleich durchzuführen, muss darauf geachtet werden, dass zwei Gleichheitszeichen genutzt werden. Ansonsten handelt es sich um eine Zuweisung und es kommt auch wiederum zu einem Syntaxfehler. 
4. Fehlende Klammern bei zusammengesetzten Bedingungen: Die Verwendung von runden Klammern zur Trennung von Bedingungen ist zwar kein Muss, kann aber helfen, die Reihenfolge der Bedingungen zu steuern. Deshalb sollte darauf geachtet werden, ob Klammern gesetzt sind und welche Bedingungen sie umschließen. 
5. Logikfehler: Vor allem bei komplexen Schleifen sollte man die Bedingungen im Detail prüfen, um sicherzustellen, dass sie richtig formuliert sind und auch die Anordnung zueinander passt. Bei der Nutzung von mehreren „elif“ Blöcken muss auch die Reihenfolge kontrolliert werden, um zu prüfen, ob alle Bedingungen wirklich sinnvoll sind. 
6. Anordnungsfehler: Die Reihenfolge in der Bedingungen getestet werden, sollte genauestens geprüft werden. Oftmals liegen vermeintliche Probleme daran, dass Code zu früh ausgeführt wird, weil bereits eine Bedingung erfüllt ist. Deshalb muss überprüft werden, ob das gewünschte Verhalten von der bedingten Schleife erfüllt wird.
7. Vereinfachung von Logiken: Viele verschachtelte Bedingungen können mithilfe von Vergleichsoperatoren oder logischen Operatoren deutlich vereinfacht werden. Dadurch lassen sich nicht nur Fehler vermeiden, sondern der Code wird dadurch auch deutlich verständlicher.

Wenn diese Punkte beachtet werden, reduziert sich das Risiko eines Fehlers bereits deutlich. Dies sind jedoch nur die häufigsten Fehlerquellen, natürlich kann es auch andere Gründe geben, die dazu führen, dass das Programm nicht durchlaufen kann. 

Das solltest Du mitnehmen

• Bedingte Anweisungen sind in verschiedenen Programmiersprachen und vor allem in Python von entscheidender Bedeutung. Sie können benutzt werden, um komplexe Algorithmen abzubilden.
• Damit lassen sich dynamische und interaktive Programme erstellen, bei denen der Ablauf des Codes aktiv gesteuert wird.
• Dabei ist es wichtig, die Syntax, die Struktur und die unterschiedlichen Komponenten von bedingten Anweisungen zu verstehen, um sauberen und effizienten Code schreiben zu können.
• Um Fehler zu vermeiden, sollte unter anderem auf die konsistente Einrückung und das Hinzufügen von Doppelpunkten geachtet werden, um einen Absturz des Programms zu verhindern.
• Die Python if-Bedingungen lassen sich außerdem mit logischen Operatoren wie dem logischen Und und dem logischen Oder verbinden, um komplexere Bedingungen zu prüfen und außerdem verschachtelte Anweisungen zu umgehen.
• Mithilfe von elif können mehrere Bedingungen nacheinander geprüft werden, die zur Ausführung kommen, wenn die vorangegangene Bedingung nicht zugetroffen ist. Hierbei ist jedoch die Reihenfolge zu beachten, da das Programm die Schleife überspringt, sobald die erste Bedingung zutrifft.

Andere Beiträge zum Thema Bedingte Anweisungen in Python

Einen umfassenden Überblick über Python-Kontrollflüsse und bedingte Anweisungen findest Du hier.