Python: if-else verstehen und anwenden

Die if-else-Anweisung in Python (zu Deutsch: „wenn-(dann)-ansonsten“) ist eine konditionelle Verzweigung und damit eine grundlegende Kontrollstruktur. Die Nutzung einer Verzweigung erlaubt, abweichende Code-Pfade je nach einer zur Laufzeit anzutreffender Bedingung zu beschreiten. Wir erklären, wie if-else in Python funktioniert und eingesetzt wird.

Bei der if-else-Anweisung handelt es sich um eine konditionelle Verzweigung. Vorstellen kann man sich das wie eine Weiche: In Abhängigkeit von einem Schaltelement wird von zwei möglichen Wegen ausschließlich einer beschritten. Python ist eine interpretierte Sprache; der Interpreter liest Zeilen des Quellcodes von oben nach unten ab. Im einfachsten Fall ergibt sich ein strikt linearer Programmfluss: Alle Zeilen werden nacheinander gelesen, interpretiert und ausgeführt.

Diesem simplen Schema folgend sind jedoch keine komplexen Programme möglich. Erst durch den Einsatz von Kontrollstrukturen ergibt sich die im praktischen Einsatz benötigte Variabilität des ausgeführten Codes. Eine Verzweigung erlaubt die konditionelle Ausführung bestimmter Code-Teile. Als weitere Kontrollstrukturen kommen insbesondere Python-for-Schleifen und Pyhton-while-Schleifen zum Einsatz, die die wiederholte Ausführung von Code-Teilen ermöglichen.

Generell verhält sich die if-else-Anweisung in Python ähnlich wie aus anderen Sprachen bekannt. Es gibt jedoch einige Python-spezifische Besonderheiten. Schauen wir uns im Detail an, wie die if-else-Anweisung in Python funktioniert und wie sie sich im Gegensatz zu anderen Sprachen verhält.

Die generelle Syntax der if-else-Anweisung in Python lässt sich direkt in Python-Code ausdrücken. Wir definieren eine Kondition und legen im Körper der if-Anweisung beispielshalber einen Funktionsaufruf als Code-Pfad fest, der beschritten wird, wenn die Kondition wahr wird. Ferner legen wir im else-Körper einen Code-Pfad fest, der andernfalls beschritten wird:

Die definierte Kondition kann entweder wahr sein (True) oder nicht wahr (False). Wir verdeutlichen das Muster, indem wir das Literal True oder False direkt als Kondition eintragen. Es ergibt sich ein statischer Programmfluss, bei dem garantiert jeweils nur einer der beiden Pfade beschritten wird:

Selbstverständlich ist dieses Muster nicht praktisch, sondern dient nur zum Veranschaulichen. Anstelle eines statischen True/False-Wertes kommt als Kondition ein Ausdruck zum Einsatz. Der Ausdruck wird zur Laufzeit des Programms ausgewertet. Man spricht davon, dass der Ausdruck „evaluiert“ wird. Beim Evaluieren des Ausdrucks ergibt sich ein Wahrheitswert. Je nachdem, ob als Wahrheitswert True oder False herauskommt, verzweigt das Programm in die eine oder die andere Richtung.

Wichtig zu verstehen ist, dass der else-Teil optional ist. Der im else-Körper befindliche Code wird nur ausgeführt, wenn die Kondition nicht zutrifft. Dies ist jedoch nicht zwingend notwendig. Oft genügt eine alleinstehende if-Anweisung:

Ein kleiner Hinweis zur Nomenklatur: Wir haben die Begriffe „Anweisung“ und „Ausdruck“ benutzt, ohne diese zu erklären. Dabei ist es durchaus wichtig, zu verstehen, was damit gemeint ist. Denn diese beiden grundlegende Begriffe ziehen sich durch sämtliche Programmiersprachen. Hier die Bedeutung der Begriffe im Überblick:

Neben der bekannten if-else-Anweisung existiert in Python die verwandte elif-Anweisung. Auf eine if-Anweisung folgen optional mehrere elif-Anweisungen, gefolgt von einem optionalen else-Block. Eine elif-Anweisung wird nur dann ausgeführt, wenn keine der vorgeschalteten Konditionen wahr geworden ist. So wird garantiert, dass ausschließlich ein einzelner definierter Code-Pfad beschritten wird:

Hier die Regeln für den Aufbau einer verketteten if-elif-else-Verzweigung:

Die if-else-Anweisung ist in Python wie in anderen Sprachen eine grundlegende Funktionalität. Naturgemäß gibt es viele verschiedene Einsatzmöglichkeiten. Wir zeigen häufig anzutreffende Beispiele inklusive Best Practices und Anti-Patterns.

Schauen wir uns zunächst an, wie die Kondition einer Verzweigungs-Anweisung funktioniert. Die Kondition wird als boolescher Ausdruck interpretiert, der zu einem der Wahrheitswerte True oder False evaluiert. Es ist daher unnötig, explizit auf Gleichheit mit einem booleschen Literal zu testen:

Auch wenn es sich beim expliziten Abgleich mit True nicht um einen echten Fehler handelt, wirkt der Code unprofessionell. Erfahrene Programmierer schreiben stattdessen:

Schauen wir uns das Anti-Pattern an einem Beispiel an. Nehmen wir an, dass eine Funktion is_odd() für eine Zahl True zurückgibt, wenn die Zahl ungerade ist. Andernfalls gibt die is_odd-Funktion False zurück. Wir nutzen die Funktion innerhalb einer if-Anweisung und geben einen entsprechenden Text aus:

Stellen wir uns vor, was beim Durchlaufen der Verzweigung mit einer ungeraden Zahl passiert. Zunächst evaluiert der Ausdruck 'is_odd(number) == True' zu 'True == True'. Letzterer evaluiert wiederum zu 'True'; der if-Körper wird ausgeführt. Sinnvoller ist, den von der is_odd-Funktion zurückgegebenen booleschen Wert direkt als Kondition zu nutzen:

Stellen wir uns die folgende Situation vor: Wir haben einen Code-Block mit bestimmter Funktion. Die Zeilen werden nacheinander ausgeführt. Jedoch soll ein Bestandteil des Codes nicht immer ausgeführt werden, sondern nur dann, wenn eine Bedingung zutrifft. Um dieses Muster umzusetzen, benötigen wir lediglich eine if-Anweisung. Hier dargestellt am Beispiel einer Nutzerregistrierungs-Routine:

Häufig müssen Programme zwischen zwei sich gegenseitig ausschließenden Fällen unterscheiden. Wenn sich logisch erschließt, dass es keine weiteren Fälle geben kann, ist es sinnvoll, eine if-else-Anweisung einzusetzen. Wir testen exemplarisch, ob eine Person ein bestimmtes Alter erreicht hat, und geben jeweils ein passendes Ergebnis aus:

Gibt es mehr als zwei sich gegenseitig ausschließende Fälle, zwischen denen wir unterscheiden möchten, kommen verkettete elif-Anweisungen zum Einsatz. Ein abschließendes else dient dazu, unbekannte Variation zu fangen. Wir ordnen Ländernamen den korrespondierenden Länder-Codes zu:

Sofern sich die elif-Kette innerhalb einer Funktion befindet, ist es manchmal besser, mehrere unabhängige if-Anweisungen zu nutzen. So sparen wir uns die Zuweisung im elif-Körper. Mittels der return-Anweisung verlassen wir die Funktion, wenn eine der Bedingungen wahr wird. Statt dem abschließenden else kommt eine zuletzt stehende return-Anweisung zum Einsatz, die nur erreicht wird, wenn keine der Konditionen True war:

Verkettete elif-Anweisungen sind ein bekanntes Muster älterer Sprachen. In Python ist es oft direkter, ein „Dictionary Lookup“ zu verwenden. Wir definieren die Zuordnung der Codes zu den Ländernamen direkt und extrahieren den Namen anhand des Codes. Anstatt des abschließenden else nutzen wir die eingebaute get-Methode, die als zweiten Parameter einen Default-Wert entgegennimmt:

Python ist eine dynamisch und lose typisierte Sprache. Statt an Variablen sind Typen an Werte gebunden. Je nach Einsatz finden ggf. implizite Konversionen zwischen Typen statt. Im Kontext der booleschen Ausdrücke spricht man in Erweiterung der Wahrheitswerte True und False auch von „truthy“ und „falsy“.

Das bedeutet, dass die Kondition einer if-Anweisung in Python nicht explizit zu True oder False evaluieren muss. Vielmehr können Werte anderer Typen als Kondition zum Einsatz kommen. Diese werden bestimmten Regeln folgend als boolesche Werte interpretiert.

Wir machen uns dieses Muster zunutze, um zu überprüfen, ob ein Objekt Daten enthält. Da der folgende Text leer ist, wird eine entsprechende Meldung ausgegeben:

Die folgenden Objekte evaluieren im booleschen Kontext zu False und werden daher als „falsy“ bezeichnet:

Ein weiteres Beispiel mit einer leeren Liste:

Alle anderen Objekte evaluieren zu True:

Auch zum Hin- und Herschalten zwischen zwei exklusiven Zuständen kommt eine if-else-Anweisung zum Einsatz. Das Prinzip ähnelt einem Lichtschalter und wird im Englischen als „Toggle“ bezeichnet. Wir definieren eine Funktion, die den Zustand eines Lichts umdreht:

Vielleicht sehen Sie es bereits: Das geht noch einfacher. Sofern der Zustand nicht als String, sondern als boolescher Wert repräsentiert wird, bietet sich an, komplett auf die if-Anweisung zu verzichten. Stattdessen nutzen wir den logischen NICHT-Operator, um den booleschen Wert umzudrehen:

In der Praxis ist es üblich, bestimmten Code auszuführen, wenn mehrere Konditionen gleichzeitig wahr werden. Dies führt bei unerfahrenen Programmierern schnell zu verschachtelten if-Anweisungen. Jedoch handelt es sich dabei um schlechten Stil. Denn tief verschachtelte Verzweigungen lassen sich schwer überblicken und schlecht warten.

Betrachten wir ein Beispiel: Wir schreiben eine Funktion, die die Aussage darüber wiedergibt, ob eine Person wählen darf. Wir überprüfen zunächst, ob die Person ein Ausweisdokument hat. Im Anschluss überprüfen wir, ob die Person das Wahlalter bereits erreicht hat. Eine erste Implementation der Funktion enthält verschachtelte if-Anweisungen:

Ein unmittelbares Problem dieser Implementation ist, dass der wichtigste Code weiter eingerückt wird, je mehr Bedingungen getestet werden. Zum Auflösen verschachtelter if-Anweisungen kommt die Best Practice des „Early Return“ zum Einsatz. Dabei überprüfen wir am Anfang der Funktion, ob die einzelnen Bedingungen erfüllt sind. Ist eine Bedingung nicht erfüllt, brechen wir ab und verlassen die Funktion unter Nutzung der return-Anweisung.

Wir formulieren unsere Funktion neu, um Early Returns zu nutzen. Häufig erfordert dies, die vorher definierten Bedingungen umzukehren. Hilfreich ist dabei ein Verständnis der booleschen Operatoren in Python. Trifft keine der negativen Bedingungen zu, wird der eigentlich interessante Code ausgeführt:

Wie wir bereits gesehen haben, ist es häufig notwendig, das Eintreten mehrerer Konditionen zu testen. Meist ist es suboptimal, zum Testen mehrerer Bedingungen verschachtelte if-Anweisung zu nutzen. Betrachten wir exemplarisch Code, der bestimmt, ob eine Person wählen darf:

Schöner lässt sich die verkettete Bedingung unter Nutzung logischer Operatoren darstellen. Da wir testen wollen, ob beide Konditionen gleichzeitig zutreffen, nutzen wir den logischen UND-Operator. So benötigen wir nur eine einzige if-Anweisung:

Hier ein Überblick der grundlegenden logischen Operatoren in Python:

Neben dem Verknüpfen von Operanden in Konditionen werden die logischen Operatoren eingesetzt, um bestimmte if-Anweisungen zu ersetzen. Es handelt sich dabei um das Setzen von Default-Werten.

Betrachten wir ein Beispiel: Stellen wir uns vor, ein Nutzer könne für eine finanzielle Berechnung eine Währung festlegen. Aus Gründen der Benutzerfreundlichkeit soll die Wahl optional sein. Wählt der Benutzer keine Währung aus, soll EUR als Default-Wert verwendet werden. Der folgende Code bildet dieses Prinzip ab:

Unter Einsatz des logischen ODER-Operators lässt sich die if-Anweisung auflösen. Wir schreiben den Code um; wird dieser ausgeführt, enthält die currency-Variable den Wert 'EUR':

Was genau geschieht hier? In der letzten Zeile wird der Variable 'currency' ein neuer Wert zugewiesen. Dazu wird zunächst der Ausdruck 'currency or 'EUR'' auf der rechten Seite des Gleichheitszeichens evaluiert. Der logische ODER-Operator evaluiert zunächst den linken Ausdruck, in diesem Falle 'currency'. Da dieser im Beispiel 'None' enthält und damit „falsy“ ist, wird der rechte Ausdruck 'EUR' evaluiert und als Rückgabewert für die Zuweisung verwendet.

Neben der konditionellen Verzweigung gibt es einen weiteren Nutzen der if-else-Schlüsselworte in Python. Es handelt sich um den konditionalen Operator, auch bekannt als „ternärer“ Operator. Der konditionale Operator wird gerne eingesetzt, um in Zuweisungen zwischen zwei möglichen Werten zu unterscheiden.

Betrachten wir zunächst ein Beispiel unter Nutzung der if-else-Anweisung in Python. Der folgende Code legt Celsius oder Fahrenheit als Einheit für eine Temperaturmessung in Abhängigkeit vom gewählten Messsystem fest:

Unter Nutzung des konditionalen Operators lässt sich der Code zu einer einzelnen Zuweisung vereinfachen:

Wie der Name ausdrückt, nimmt der ternäre Operator drei Operanden entgegen: die beiden möglichen Werte und einen Ausdruck als Bedingung.

Mit dem Erscheinen der Python-Version 3.10 wurde die match-case-Anweisung eingeführt. Diese erinnert zunächst an die switch-case-Anweisung anderer Sprachen. Dort kommt switch-case zum Einsatz, um große if-elif-else-Konstrukte aufzubrechen.

Da als fehleranfällig berüchtigt, gab es switch-case in Python nie. Vielmehr handelt es sich bei der match-case-Anweisung in Python um eine an funktionale Sprachen wie Haskell angelehnte Funktionalität für „Structural Pattern Matching“. Der Nutzen geht weit über den von switch-case hinaus.

Veranschaulichen wir uns das Prinzip von match-case an einem Beispiel: Stellen wir uns vor, wir wollen Daten von Personen in verschiedenen Formaten verarbeiten. Eine Person kann entweder als einzelner Name abgebildet sein oder als Dictionary mit Name und ggf. Alter oder als Tupel von Vor- und Nachname. Ferner wollen wir den exakten Namen „Jack“ besonders behandeln:

Schauen wir uns zunächst eine Funktion an, die eine Person in einem der Formate begrüßt. Wir nutzen eine if-elif-else-Kette und die isinstance-Funktion, um die verschiedenen Formate zu unterscheiden. Ferner kommen mit dem UND-Operator verkettete Konditionen und eine verschachtelte if-else-Anweisung zum Einsatz. Der finale Code wirkt nicht besonders übersichtlich:

Schöner lässt sich der Code mit der match-case-Anweisung aufbauen. Wir beschreiben die Struktur der einzelnen Formate direkt; einzelne Werte lassen sich als Variablen extrahieren. Der Code ist übersichtlicher, weniger komplex und besser lesbar: