Bei bedingten Anweisungen und Verzweigungen wird Code «selektiv» ausgeführt. Er wird nur ausgeführt, wenn eine bestimmte Bedingung erfüllt ist. Progammierstruktur: Selektion
Table of Contents
Dieser Blog wird vom IAIP gratis zur Verfügung gestellt und ist einer aus einer Reihe von Einführungsblogs zum Thema «Programmieren mit Python».
Der Blog ist ein Bestandteil des Kurses «Einführung in Python Teil 1». Der Kurs führt dich durch die einzelnen Blogs, enthält Zusatzmaterialien, viele Aufgaben mit Lösungen und Quizze zur Lernkontrolle. Der Kurs hat eine Kursgebühr von CHF 50.- Mit dem Einschreiben zum Kurs hilfst du mit, dass solche Blogs auch zukünftig noch gratis zur Verfügung gestellt werden können.
Bedingte Anweisungen und Verzweigungen
Bedingte Anweisungen mit if realisieren
Man wird kaum ein sinnvolles Programm schreiben können, welches ohne jede Art von Bedingungen auskommt. In der Regel hat jedes Programm haufenweise Anweisungen, welche nur in gewissen Situationen, d.h. unter gewissen Bedingungen, ausgeführt werden sollen. Solche «bedingte Anweisungen» gehören gewissermassen zum 1×1 jeder Programmiersprache. Denn ansonsten würde das Programm jedes Mal exakt dasselbe machen.
Schauen wir uns ein kleines Beispiel an:
zustand = input("Wie geht es dir heute? ")
if zustand == "gut":
print("Das freut mich!")
print("Mir geht es auch gut.")
print("\nund weiter geht's...") Das Programm fragt unseren User, wie es ihm geht. Seine Eingabe wird in der Variable zustand abgelegt. Geht es dem User «gut», dann antwortet das Programm: «Das freut mich!» und anschliessend «Mir geht es auch gut.». Ansonsten überspringt es die 2 print() Funktionsaufrufe einfach.
Bedingte Anweisungen sind also Befehle, welche dann ausgeführt werden, wenn eine gewisse Bedingung erfüllt ist. Solche Strukturen werden in den meisten Programmiersprachen durch die if Anweisung umgesetzt. Das Wort «if» stammt aus dem Englischen und bedeutet zu Deutsch «wenn» bzw. «falls». Die if Anweisung wird benutzt, um den Programmablauf in einem Python-Programm zu steuern. Damit können wir zur Laufzeit entscheiden, ob bestimmte Programmteile ausgeführt werden sollen oder nicht.
Die Syntax einer bedingten Anweisung in Python ist wie folgt:
if Bedinung
Anweisung 1
Anweisung 2
Anweisung 3
Selbstverständlich kann man beliebig viele Blöcke mit bedingten Anweisungen in einem Programm haben. Wir können beispielsweise unser Programm erweitern:
zustand = input("Wie geht es dir heute? ")
if zustand == "gut":
print("Das freut mich!")
print("Mir geht es auch gut.")
if zustand == "schlecht":
print("Das tut mir aber leid.")
print("\nund weiter geht's...") Je nach Eingabe antwortet der Computer nun unterschiedlich. Geht es dem User «gut», dann antwortet das Programm wie gewohnt: «Das freut mich!» und «Mir geht es auch gut.». Und geht es ihm «schlecht», so lautet die Antwort nun: «Das tut mir aber leid.». Über unterschiedliche Bedingung steuert man so den Programmfluss, d.h. das, was der Computer machen soll. Die Bedingung, also der Teil, welcher entscheidet, was gemacht werden soll, ist in diesem Fall der Zustand des Users. Wir wollen ja nicht, dass der Computer «Das freut mich!» schreibt, wenn es dem User schlecht geht.
Zur Illustration ist nachfolgend die jeweilige Ausgabe des Programms abgebildet, je nachdem ob es unserem User «gut», «schlecht» oder sonst irgendwie geht.
In der Fachsprache spricht man von einem zusammengesetzten Kommando. Es besteht aus 3 Teilen:
- Es beginnt mit dem Schlüsselwort if. Das Schlüsselwort sagt dem Computer, dass es sich bei den nachfolgenden Befehlen um bedingte Anweisungen handelt. Also Anweisungen, die nur ausgeführt werden, falls eine Bedingung erfüllt ist.
- Direkt anschliessend folgt die Bedingung, welche der Computer überprüfen soll. Diese wird ausgewertet, und falls sie erfüllt ist (und nur dann) wird ein spezieller Codeabschnitt ausgeführt.
Diese ersten zwei Teile bezeichnet man auch als Kopf des Kommandos. Der endet in Python mit einem Doppelpunkt.
- Der Codeabschnitt (Rumpf) seinerseits kann aus einer oder mehreren Anweisungen besteht. Dies sind die eigentlichen (bedingten) Anweisungen. Die Anweisungen sind eingerückt, und in der Regel steht pro Programmzeile eine Anweisung. Theoretisch könnt man auch mehrere Kommandos auf eine Zeile schreiben, sofern man diese durch Semikolons (Strichpunkte) trennt. Es ist aber eher unübersichtlich und wird deshalb nicht empfohlen.
zustand = input("Wie geht es dir heute? ")
if zustand == "gut": print("Das freut mich!"); print("Mir geht es auch gut.")
if zustand == "schlecht": print("Das tut mir aber leid.")
print("\nund weiter geht's...") Anschliessend wird in jedem Fall die Programmausführung mit den auf die bedingte Anweisung folgenden, nicht eingeschobenen Befehlen fortgesetzt. In unserem Programmbeispiel ist dies der zweite if Block mit den bedingten Anweisungen und anschliessend der Befehl print(«\nund weiter geht’s…»).
Besonders zu beachten ist:
- Für Vergleiche verwenden wir in Python nicht das Gleichheitszeichen = , sondern zwei direkt aneinander gereihte == . Ersteres, also ein einzelnes Gleichheitszeichen, ist kein Vergleich, sondern eine sogenannte Zuweisung. Dadurch wird einer Variablen ein Wert zugewiesen. So wie beispielsweise in der ersten Programmzeile. Dort wird die Eingabe des Users der Variable zustand.
- Nach der Bedingung steht jeweils ein Doppelpunkt.
- Zusammengehörige Anweisungen sind immer gleich viel eingerückt. Dadurch weiss der Interpreter, welche Anweisungen einen Block bilden. Im Programmbeispiel erkennt der Interpreter so, dass die Anweisung «print("\nund weiter geht's...")» nicht mehr zur Bedingung «zustand == "schlecht"» gehört.
Manchmal ist es hilfreich, die Funktionsweise bedingter Anweisungen ganz abstrakt anhand eines sog. Struktogramms oder eines Flussdiagramms darzustellen. Solche Struktogramme und Flussdiagramme sind bekannte Hilfsmittel bei der Entwicklung von Algorithmen. Sie haben aber auch einen hohen didaktischen Wert, insbesondere wenn es darum geht, die Funktionsweise von Kontrollstrukturen (bedingte Anweisungen, Verzweigungen, Schleifen) zu illustrieren.
Verzweigungen mit if und else erstellen
Über die if-Anweisung kann man eine Kommandofolge auszuführen, falls eine Bedingung erfüllt ist. Doch was passiert, wenn die Bedingung nicht erfüllt ist?
Nutzt man zusätzlich das Schlüsselwort else, so lässt sich eine Kommandofolge ausführen, wenn die Bedingung «wahr» ist, und eine andere, wenn sie «falsch» ist. Der Begriff «else» ist wiederum Englisch und bedeutet zu Deutsch etwa soviel wie «sonst» oder «anderenfalls».
Hierzu ein Anschauungsbeispiel:
zustand = input("Wie geht es dir heute? ")
if zustand == "gut":
print("Das freut mich!")
print("Mir geht es auch gut.")
else:
print("Ich verstehe das Wort", zustand, "leider nicht")
print("\nund weiter geht's...") Am besten probiert man das Programm selber aus. Spannend wird es, wenn der User beispielsweise das Wort «mies» eingibt. Es erscheint Folgendes:
Eine Verzweigung (auch Auswahl oder Selektion genannt) besteht aus einer Bedingung und zwei Codeabschnitten. Wieder wird die Bedingung ausgewertet, und falls sie zutrifft, wird anschliessend der erste Codeabschnitt ausgeführt. Neu wird nun aber für den Fall, dass die Bedingung nicht zutrifft, der zweite Codeabschnitt ausgeführt. Die Verzweigung legt fest, welcher von zwei Programmteilen (Alternativen) in Abhängigkeit von einer Bedingung ausgeführt wird.
Die Syntax einer Verzweigung in Python ist wie folgt:
if Bedinung:
Anweisung(en)
else:
Anweisung(en)
Besonders zu beachten ist:
- Das Schlüsselwort else ist auf derselben Einrückungsebene wie die zugehörige if.
- Nach else steht jeweils ein Doppelpunkt.
- Die zu else zugehörigen Anweisungen (also jene, welche ausgeführt werden sollen, wenn die Bedingung nicht erfüllt ist) sind wiederum eingerückt. Stilistisch sauber ist, wenn der Einschub gleich gross wie bei den bedingten Anweisungen des ersten Teils ist. Zwingend notwendig ist dies jedoch nicht.
Nachfolgend ist die Funktionsweise einer einfachen Verzweigung anhand eines Struktogramms und eines Flussdiagramms dargestellt.
Mehrfachverzweigungen und Verschachtelungen
Verschachtelung
Beim letzten Beispielprogramm haben wir heimlich etwas weggelassen. Nämlich die Möglichkeit, dass es unserem User schlecht geht. Während beim ersten Programm der Computer mit «Das tut mir aber leid» geantwortet hat, gibt es im letzten Programm diese Option nicht mehr. Der Computer versteht das Wort einfach nicht.
Eine Möglichkeit zur Lösung dieses Problems liegt in der Verschachtelung (engl.: nested) von bedingten Anweisungen. Etwa so:
zustand = input("Wie geht es dir heute? ")
if zustand == "gut":
print("Das freut mich!")
print("Mir geht es auch gut.")
else:
if zustand == "schlecht":
print("Das tut mir aber leid.")
else:
print("Ich verstehe das Wort", zustand, "leider nicht")
print("\nund weiter geht's...") Solche verschachtelten Strukturen trifft man in Programmcodes sehr oft an. Insbesondere auch bei Schleifen. Bei Python muss man dabei wie erwähnt besonders auf die Einschübe achten. Aber grundsätzlich kann man in jedem Block (also im if block und im else Block) und auch beliebig oft bzw. tief verschachteln. Das heisst, jeder Codeblock besteht aus 1 oder mehreren bedingten Anweisungen. Anstelle einer gegebenen Anweisung kann man nun eine weitere Verzweigung einbauen. So entsteht eine Verzweigung (oder ein Block bedingter Anweisungen) innerhalb eines bedingten Codeblocks.
Die Struktur wird wiederum besonders deutlich anhand ihrer Darstellung im Struktogramm und im Flussdiagramm. Betrachten wir als erstes ein Struktogramm zum oben dargestellten Programm. Zur besseren Illustration wurden die zwei «Möglichkeiten» der ersten Verzweigung in grüner und blauer Farbe eingefärbt.
Ganz ähnlich erweitert sich die Struktur beim Flussdiagramm. Zur Demonstration können wir unser Beispielprogramm um eine zweite Verschachtelung erweitern und dann versuchen den Code sinngemäss in einem Flussdiagramm abzubilden:
zustand = input("Wie geht es dir heute? ")
if zustand == "gut" or zustand == "super":
print("Das freut mich!")
if zustand == "gut":
print("Mir geht es auch gut.")
else:
print("Mir geht es nur gut.")
else:
if zustand == "schlecht":
print("Das tut mir aber leid.")
else:
print("Ich verstehe das Wort \"" + zustand + "\" leider nicht")
print("\nund weiter geht's...") Die Bedingung zustand ==»gut» oder zustand == «super»: verwendet einen sogenannten logischen Operator. Konkret wird hier überprüft, ob der Benutzer entweder «gut» oder (engl.: or) «super» eingibt. Ist eine der beiden Alternativen richtig, so ist die Bedingung wahr.
Die zwei «Möglichkeiten» der ersten Verzweigung wurden wiederum in grüner und blauer Farbe eingefärbt. Ebenso mit einem gestrichelten Rahmen umrandet. Eine solche Darstellung ist aber sonst nicht üblich. Bei den Verzweigungssymbolen spielt es keine Rolle, auf welche Seite die Pfeile weggehen, solange diese beschriftet sind. «In:» steht im Beispiel für Input, «Out:» für Output.
Mehrfachverzweigungen mit elif erstellen
Grundsätzlich kann man wie gezeigt bedingte Anweisungen und Verzweigungen verschachteln. Aber es ist nicht sehr elegant. Und eine solche Lösung wird bei vielen Möglichkeiten ziemlich schnell unübersichtlich. Glücklicherweise kennt Python eine Alternative, wie man Mehrfachverzweigungen einfach realisieren kann.
zustand = input("Wie geht es dir heute? ")
if zustand == "gut":
print("Das freut mich!")
print("Mir geht es auch gut.")
elif zustand == "schlecht":
print("Das tut mir aber leid.")
else:
print("Ich verstehe das Wort", zustand, "leider nicht")
print("\nund weiter geht's...") Das entsprechende Schlüsselwort heisst elif, was letztlich bloss eine Abkürzung für else: if ist.
Bei Mehrfachverzweigungen (auch: Fallunterscheidungen) werden die Bedingungen der Reihe nach ausgewertet, solange bis eine davon zutrifft. Dann wird der zu dieser Bedingung gehörende Codeabschnitt ausgeführt und die Behandlung der mehrfachen Verzweigung ist damit beendet. Wenn keine der Bedingungen zutrifft, wird der else-Teil ausgeführt, falls er vorhanden ist.
Die Syntax einer Mehrfachverzweigung in Python ist wie folgt:
if Bedinung:
Anweisung(en)
elif Bedinung:
Anweisung(en)
elif Bedinung:
Anweisung(en)
…
else:
Anweisung(en)
Mit Mehrfachverzweigungen kann man nicht alle verschachtelten Strukturen ersetzen. Beide Ansätze haben ihre Daseinsberechtigung.
Die Funktionsweise einer Mehrfachverzweigung kann man wiederum über ein Struktogramm und eines Flussdiagramms illustrieren:
Mehrere Bedingungen und Ergebnis eines Ausdrucks
Bedingte Anweisungen und Verzweigungen werden in Programmiersprachen (ebenso wie die Schleifen) den Kontrollstrukturen zugerechnet, weil mit ihrer Hilfe ein Programm auf verschiedene Zustände, die sich aus Eingaben und Berechnungen ergeben, reagieren kann.
Bedingte Anweisungen sind Codeteile, die unter einer Bedingung ausgeführt werden. Liegt die Bedingung nicht vor, wird dieser Code nicht ausgeführt. In Python nutzt man hierzu das Schlüsselwort if. Bei anderen Programmiersprachen läuft es in der Regel gleich. Die Unterschiede sind oft nur marginal:
In C steht die Bedingung in Klammern, dafür wird kein Doppelpunkt benötigt. Und die Strukturierung (also die Markierung der bedingten Anweisungen) erfolgt über geschweifte Klammern, dafür benötigt man keinen exakten Einschub wie in Python.
Eine Verzweigung legt fest, welcher von zwei Programmteilen (Alternativen) in Abhängigkeit von einer Bedingung ausgeführt wird. Um eine Verzweigung realisieren zu können, benötigt man wie erläutert zusätzlich das Schlüsselwort else.
In fast allen Programmiersprachen stehen darüber hinaus auch Schlüsselwörter für mehrfache Verzweigungen bereit. Grundsätzlich sind dabei zwei Formen zu unterscheiden (in beiden Formen kann ein else Teil als weiterer Codeabschnitt vorhanden sein) :
- Es gibt mehrere Bedingungen, welche jeweils einen Codeabschnitt haben.
- Das Ergebnis eines Ausdrucks bestimmt, welcher von mehreren Codeabschnitten ausgeführt wird.
Während Python die erste Form (mehrere Bedingungen) kennt und über die elif Anweisung löst, existiert kein Befehl für die zweite Form (Ergebnis von Ausdruck). Zur Illustration des Unterschieds wiederum die beiden Varianten in C:
Fall 1: mehrere Bedingungen
Fall 2: Ergebnis eines Ausdrucks
Ergebnis eines Ausdrucks in Python:
Die Variante gibt es so in Python nicht. Man muss hinter jedem elif den Ausdruck einzeln auswerten.
Programmiersprachen wie C nutzen je nach Art der Mehrfachverzweigung unterschiedliche Schlüsselwörter. So wird der klassische Fall mehrerer Bedingungen (Fall 1) über die bekannte if- else if – else Struktur abgebildet, wohingegen man für den Auswertungsfall (Fall 2) das Schlüsselwort switch verwendet.
Bedingungen und ihre Möglichkeiten
Vergleiche der Operanden
Betrachten wir zuerst das nachfolgende Programm, welches einen Kommentar zum Alter einer Person abgibt.
Alter = eval(input("Bitte gib dein Alter ein: "))
if Alter == 50:
print ("Gratuliere. Du bist ein halbes Jahrhundert alt!")
if Alter < 50:
print ("Das ist aber ganz schon jung!")
if Alter > 50:
print ("Das ist aber ganz schon alt!") Wir können in Python ganz viele unterschiedliche Vergleiche anstellen. Einen Überblick der sogenannten Vergleichsoperatoren (boolsche Ausdrücke) verschafft die nachfolgende Tabelle.
| == | Gleichheit |
| != | Ungleichheit |
| < | kleiner als |
| > | grösser als |
| <= | kleiner gleich als |
| >= | grösser gleich als |
| is | Objektidentität |
| is not | Objekt- Nichtidentität |
All diese Vergleiche haben eine gemeinsame Eigenschaft: Entweder sie stimmen, oder sie stimmen nicht. Entweder das Alter ist kleiner als 50 Jahre, oder dann eben nicht. In der Fachsprache spricht man hier von einem booleschen Ausdruck. Das ist ein Ausdruck, der entweder wahr oder falsch ist. Und weil Python englische Wörter verwendet, bedeutet «wahr» in Python True und «falsch» wird False genannt. Dies sind übrigens auch gleich die einfachsten booleschen Ausdrücke – doch mehr dazu später.
Vergleich von Zeichenketten im Besonderen
Wie auch im richtigen Leben kann man auch bei Python nicht Äpfel mit Birnen vergleichen. Das soll heissen, dass die Werte bzw. Variablen links und rechts vom Operator denselben Datentyp haben müssen. Numerische Operanden werden von Python notfalls automatisch umgewandelt. Man kann also in der Praxis beispielsweise eine Ganzzahl (Datentyp int) mit einer Kommazahl (Datentyp float) vergleichen. Die Anweisung print (bool(2.3 < 5)) ist möglich und liefert als Resultat den Wahrheitswert True. Vergleichen wir aber eine Zeichenkette (Datentyp str) mit einer Zahl, so kommt es zu einem Laufzeitfehler und die Programmausführung wird abgebrochen.
Zeichenketten untereinander werden «lexikografisch» verglichen. Das heisst, der Interpreter vergleicht von links nach rechts Zeichen für Zeichen einzeln. Python vergleicht zuerst das erste Zeichen der beiden Zeichenketten, und, sind die zwei Zeichen identisch, fährt dann mit dem zweiten Zeichen fort etc. Wird das Ende beider Zeichenketten erreicht, ohne dass sich die jeweils zwei einzelnen Zeichen unterschieden haben, so sind die Ketten identisch.
Sind die Zeichenketten unterschiedlich lang, so entscheiden die Zeichen an der letzten möglichen Vergleichsposition (entspricht dem Ende der kürzeren Zeichenkette) über das Ergebnis. Deshalb kann es durchaus sein, dass eine längere Zeichenkette «kleiner» als eine kürzere Zeichenkette ist.
Sind bis zum Ende der kürzeren Zeichenkette alle Zeichen identisch, so ist die kürzere Zeichenkette natürlich auch kleiner.
Doch wie genau kann der Computer die einzelnen Buchstaben vergleichen? Wir haben bereits erläutert, dass hinter jedem Buchstaben eine Zahl steht (siehe Kapitel 3.5) Python arbeitet mit dem Unicode Standard, welcher jedem Schriftzeichen einen digitalen Code zuordnet. Der Buchstabe «a» entspricht der Zahl 97, «b» der Zahl 98, usw.
Zu beachten ist, dass Gross- & Kleinbuchstaben andere Schriftzeichen sind und so hat dann auch das grosse «A» einen anderen Zahlenwert wie das kleine «a». Vergleiche von Zeichenfolgen sind deshalb immer case-sensitiv (empfindlich gegenüber Gross- und Kleinschreibung).
Ergänzend noch zwei Hinweise:
- Manchmal sind die Zeichen in Unicode nicht in jener Reihenfolge codiert, welche einer für die Anwender eines Schriftsystems üblichen Sortierung entspricht. Solche Sortierungen sind von kontextabhängigen Regelungen geprägt (Eigenschaften der Sprachen). Hier definiert der Unicode Collation Algorithm, wie Zeichenfolgen innerhalb eines bestimmten Schriftsystems oder auch schriftsystemübergreifend sortiert werden können. Deshalb kann bei einer Sortierung (z.B. in einer Datenbankanwendung) üblicherweise nicht 1:1 die Reihenfolge der Unicode Codepunkte verwendet werden.
- Die logische Gleichheit == oder Ungleichheit != sind nicht mit der Objektidentität is oder der Objekt- Nichtidentität is not zu verwechseln. Es kann durchaus sein, dass zwei absolut identische Wörter eine unterschiedliche Objektidentität haben.
Der bool Datentyp – wahr oder falsch
Ein boolescher Ausdruck kann immer nur True oder False sein, je nachdem, ob die im Ausdruck enthaltene Aussage stimmt oder eben nicht. Man kann auch sagen, dass die Aussage nur zwei Werte annehmen kann. Der Wert 1 steht dabei für True, und der Wert 0 für False. True und False, bzw. eben 1 und 0, sind zwei mögliche boolesche Werte. In der Tat sind es die zwei einzigen boolschen Werte. In der Mathematik würde man sagen: die Menge der boolschen Werte besteht aus den 2 Elementen 0 und 1.
Für boolsche Werte gibt es in Python einen eigenen Datentyp. Damit kennen wir nun bereits 4 numerische Datentypen:
| Typ | Bezeichnung | Beispiele |
| bool | Boolesche Werte | 0, 1 |
| int | Ganze Zahlen | -40, 673’456, 0, 1 |
| float | Gleitkommazahlen | -3.345, 63.45, 0.0, 1.0 |
| complex | Komplexe Zahlen | 4+3j, 6.78 + 2.1j, 0+0j, 1+0j |
Die Datentypen sind in der Reihenfolge ihrer Mächtigkeit aufgelistet. D.h. die ganzen Zahlen beinhalten auch die 2 boolschen Werte 0 und 1, die Gleitkommazahlen beinhalten alle ganzen Zahlen, und die komplexen Zahlen beinhalten alle Gleitkommazahlen.
Der boolesche Wahrheitswert eines beliebigen Ausdrucks kann mittels der Standard-Funktion bool() ermittelt werden. Hierzu einige Beispiele:
# boolescher Wert eines booleschen Ausdrucks ermitteln
a = bool(3 < 4) # a ist eine boolsche Variable (Datentyp bool)
print(a)
print()
# Beispiele
print(bool(3 < 4)) # boolscher Ausdruck
print(bool(2.3)) # "etwas" ist wahr...
print(bool("")) # ... und nichts ist falsch
print(bool(None)) # hier mit Nichts Datentyp
print()
# Achtung bei direkter Berechnung in print-Statement
print(3 < 4) # boolscher Ausdruck
print("") # nichts ist leerer String
print(None) # nichts wird als nichts deklariert
Die Ausführung des Codes führt zu folgender Ausgabe:
Im obigen Beispiel ist a eine Variable des Datentyps bool. Der Interpreter weiss dies, bzw. deklariert die Variable automatisch richtig, und entsprechend kann man mit der Anweisung print(a) den Wahrheitswert des Vergleichs anzeigen lassen. Wie bereits in Kapitel 3 gezeigt ist print() ist eine relativ flexible Ausgabeanweisung. Man kann die print() aufrufen und als Argumente ganze Ausdrücke wie Vergleiche oder Rechnungen übergeben. Theoretisch kann man deshalb die bool() Methode weglassen und den Vergleich direkt in die Klammer setzen. Allerdings funktioniert dies nicht immer, wie man aus den oben abgebildeten Beispielen leicht erkennen kann.
Verkettung von Bedingungen (and, or, not)
Mit booleschen Operatoren können mehrere boolesche Ausdrücke verkettet werden. So können komplizierte Bedingungen wie „Ist A gleich B oder B gleich C“ formuliert werden.
Nachfolgend sind die Operatoren in der Übersicht abgebildet:
| and | Der Operator and liefert genau dann den Wert True, wenn die Ausdrücke links und rechts des Operators wahr sind. Es handelt sich um eine Verknüpfung. | (2<3) and (5>2) ergibt True (2<3) and (5<2) ergibt False (2>3) and (5>2) ergibt False (2>3) and (5<2) ergibt False |
| or | Ist wahr, wenn der Ausdruck links oder der Ausdruck rechts des Operators wahr ist. Es ist auch wahr, wenn beide wahr sind. Es handelt sich um eine oder Verknüpfung. | (2<3) and (5>2) ergibt True (2<3) and (5<2) ergibt True (2>3) and (5>2) ergibt True (2>3) and (5<2) ergibt False |
| not | Kehrt den Wahrheitswert eines Ausdrucks um. Der Operator liefert False, wenn sein Operand wahr ist, bzw. True, wenn der Operand falsch ist. | not(2<3) ergibt False not(2>3) ergibt True |
In der Fachsprache bezeichnet man boolesche Operatoren auch als logische Operatoren. In einigen Programmiersprachen existiert ferner der xor Operator. Er funktioniert ähnlich wie die or Bedingung. Allerdings trifft diese nur zu, wenn der linke oder der rechte Ausdruck wahr ist. Bei beiden wird kein Signal weitergegeben.
Conditional Expressions (Ternary Operators)
Ein Sonderfall in Python nehmen die so genannten Conditional Expressions (auch bedingte Operatoren, Ternary Operators) ein. Hierzu wiederum ein kleines Beispiel:
b, c = 5, 6 d = "wahr" if c > b else "falsch" print(d)
In seiner einfachsten Form lautet die Syntax der bedingten Operatoren wie folgt:
<expr> if <conditional_expression> else <expr2>
Sie unterscheiden sich von den gezeigten bedingten Anweisungen und Verzweigungen insofern, als es sich hier weniger um eine eigentliche Kontrollstruktur handelt, welche den Programmablauf steuern soll. Vielmehr ist ein bedingter Operator eher ein Operator, welcher einen Ausdruck definiert. Im obigen Beispiel wird zuerst der bedingte Ausdruck c > b ausgewertet. Hat er den boolschen Wahrheitswert True, so wird der Variable d die Zeichenfolge «wahr» zu geordnet. Ist er False, so wird d die Zeichenfolge «falsch» zugeordnet.
Die Reihenfolge der Ausdrücke gemäss Syntax sollte man hier nicht beachten: Der mittlere Ausdruck wird zuerst ausgewertet, und basierend auf diesem Ergebnis wird einer der Ausdrücke an den Enden zurückgegeben.
Es ist leicht ersichtlich, dass Conditional Expressions eine Art komprimierte Verzweigungen darstellen. Man hätte anstelle des bedingten Operators geradesogut auch folgende Verzweigung programmieren können.
if c > b:
d = "wahr"
else:
d = "falsch" Sie verhalten sich syntaktisch wie ein eigener Ausdruck. D.h. der Operator kann auch selbst als Teil eines längeren Ausdrucks verwendet werden.
Der bedingte Operator hat allerdings eine niedrigere Priorität als praktisch alle anderen Operatoren. Im Beispiel bildet 6 + a einen Ausdruck, da der Additionsoperator + eine höhere Priorität geniesst. Um ihn für sich zu gruppieren sind daher Klammern erforderlich. Sie sind übrigens auch unabhängig davon zu empfehlen, da bei komplexeren Strukturen mit bedingten Operatoren die Lesbarkeit des Codes rasch abnimmt.
Der Vollständigkeit halber ist nachfolgend noch ein Beispiel abgebildet, in welchem eine Mehrfachverzweigung über bedingte Operatoren realisiert wird.
Auswertungsreihenfolge boolescher Operatoren
Eine Besonderheit von Programmiersprachen liegt in ihrer Reihenfolge der Auswertung von Verknüpfungen. Grundsätzlich kann man sich merken, dass Python gewissermassen in Leserichtung von links nach rechts auswertet.
Beim and Operator wird also beispielsweise zuerst der linke Operand ausgewertet, und wenn dieser ein «falsches» Ergebnis liefert, wird der rechte Operand völlig ignoriert, da sein Wert für das Gesamtergebnis nicht mehr relevant ist (es ist so oder so «falsch»).
Dies ist oft nützlich, etwa in Konstruktionen wie jener unter dem Prompt In[3]. Hier verhindert man eine Fehlermeldung durch eine allfällige Division durch 0.
Python gestattet es übrigens auch, Vergleiche aneinanderzureihen. Ein passendes Beispiel findet sich unter In[4]. Der Ausdruck a<b<c ist äquivalent zu (a<b and b<c).