Im ersten Teil dieses Tutorials haben wir die absoluten Grundlagen der Programmierung mit Python gelernt. Wir haben die Datentypen String, Integer und Float kennengelernt, haben Operatoren benutzt und mithilfe der print() und input() Funktionen sogar erste, kleine Programme geschrieben.
Dabei haben wir gesehen, dass Python unseren Code eigentlich immer ganz strikt Zeile für Zeile ausgeführt hat. Schauen wir doch nochmal kurz ein Beispiel an.
print("Das ist die erste Ausgabe")
print("Das ist die zweite Ausgabe")
print("Das ist die dritte Ausgabe")
name = input("Was ist dein Name? ")
print("Dein Name ist also " + name)Das ist die erste Ausgabe
Das ist die zweite Ausgabe
Das ist die dritte Ausgabe
Was ist dein Name? Johannes
Dein Name ist also JohannesPython geht hier ganz einfach der Reihenfolge nach. Zuerst bekommen wir die drei Ausgaben der print()-Statements aus den Zeilen 1 bis 3. Danach kommt die Abfrage des Namens aus Zeile 4 und nachdem wir einen Namen angegeben haben wird das letzte print()-Statement in Zeile 5 ausgeführt.
Das Ganze ist also eine Art To-Do Liste für Python, die abgearbeitet wird. Aber das ist natürlich nicht die Art und Weise wie auch interessantere und komplexere Programme später funktionieren. Deshalb lernen wir jetzt ein neues Konzept kennen, das wiederum Teil vieler Programmiersprachen ist – der sogenannte Control Flow.
Control Flow (deutsch etwa: Kontrollfluss) erlaubt es uns gewisse Anweisungen an Python in unseren Code zu schreiben, die es erlauben den Programmablauf etwas dynamischer zu gestalten. Man kann manche Dinge nur abhängig von verschiedenen Bedingungen ausführen, Dinge für eine gewisse Anzahl an Durchläufen ausführen oder sogar so lange weiter ausführen, bis eine gewisse Bedingung erfüllt ist.
Den Ablauf eines Programms mit diesen Control Flow Elementen kann man eigentlich genau mit einem Flow-Chart abbilden. Sehen wir uns doch einmal folgende Visualisierung an.
In einem solchen Flow-Chart ist normalerweise nicht von vornherein klar, welchen Weg man gehen wird. Es gibt unterschiedliche Auswahlmöglichkeiten und je nach der Entscheidung gibt es am Ende vielleicht auch ganz andere Ausgänge.
Aber bevor wir uns jetzt weiter mit dem Kontrollfluss selbst beschäftigen müssen wir noch einen wichtigen Datentyp kennenlernen, der es uns überhaupt erst erlaubt diese Ja und Nein Entscheidungen zu treffen – Bools.
Booleans in Python
Viele, bzw. eigentlich alle Datentypen, die wir bis jetzt kennen (String, Int und Float) können eigentlich unterschiedlichste Werte haben. Es gibt ja jede Menge Zahlen und auch der Text eines Strings kann alles beinhalten. Der Typ Boolean oder kurz Bool hingegen kann nur einen von zwei möglichen Werten annehmen: True oder False – das bedeutet wahr oder falsch.
Eine Bool-Variable ist eigentlich ganz leicht erstellt. Wir müssen einer Variablen einfach entweder das Wort True oder das Wort False zuweisen. In beiden Fällen starten wir mit einem Großbuchstaben und verwenden eine Anführungszeichen wie bei Strings. Dann erkennt Python unseren Wert als Bool.
wahr = True
falsch = FalseAuch wenn wir Bool-Werte oft direkt definieren, kommt es wahrscheinlich genauso oft vor, dass wir Ausdrücke schreiben, die Python zu einem Bool-Wert evaluiert. Dazu verwenden wir spezielle Operatoren, mithilfe derer man zwei Werte vergleichen kann.
Vergleichsoperatoren in Python
Ein Vergleichsoperator – wie der Name schon ein bisschen andeutet – wird dazu benutzt, zwei Werte zu vergleichen und festzustellen, ob der Vergleich stimmt oder nicht. Dementsprechend wird der Wert True oder False zurückgegeben.
In Python existieren die folgenden Vergleichsoperatoren.
| Operator | Bedeutung |
| == | Ist gleich… |
| != | Ist nicht gleich… |
| < | Ist kleiner als… |
| > | Ist Größer als… |
| <= | Ist kleiner oder gleich… |
| >= | Ist größer oder gleich… |
Am einfachsten kann man die Operatoren mit Zahlen ausprobieren. Sehen wir uns doch einmal folgende Ausdrücke in der Konsole an und schauen, was Python zurückgibt.
10 == 10
# 10 ist gleich 10 -> Ausgabe: True
10 == 100
# 10 ist gleich 100 -> Ausgabe: False
10 != 20
# 10 ist nicht gleich 20 -> Ausgabe: True
10 < 20
# 10 ist kleiner als 20 -> Ausgabe: True
10 > 20
# 10 ist größer als 20 -> Ausgabe: False
10 <= 10
# 10 ist kleiner oder gleich 10 -> Ausgabe: True
10 >= 9
# 10 ist größer oder gleich 9 -> Ausgabe: TrueDiese Vergleiche zwischen Zahlen sind eigentlich ziemlich logisch und gut nachvollziehbar. Vor allem die == und != Operatoren funktionieren aber eigentlich auch gut mit den anderen Datentypen.
'Johannes' == 'Johannes'
# Johannes ist gleich Johannes -> Ausgabe: True
'Johannes' == 'joHannes'
# Johannes ist gleich Hallo -> Ausgabe: False
'Johannes' != 'Timothy'
# Johannes ist nicht gleich Timothy -> Ausgabe: True
100 == 100.0
# 100 ist gleich 100.0 -> Ausgabe: True
100 != 100.3
# 100 ist nicht gleich 100.3 -> Ausgabe: True
100 == '100'
# 100 ist gleich "100" (als String) -> Ausgabe: FalseHier muss man ein bisschen genauer schauen. Bei Strings ist klar, dass nur dann wenn beide Strings genau gleich sind auch durch einen Operator diese Gleichheit bestätigt wird. Es reicht schon ein Unterschied bei der Groß- und Kleinschreibung, dass dies nicht mehr der Fall ist, wie in Zeile 3.
Integer und Floats gelten als gleich, wenn sie dieselbe Zahl beschreiben. 10 und 10.0 sind beispielsweise gleich. Wenn ich allerdings einen Integer oder Float mit derselben Zahl als String vergleiche (siehe Zeile 16), dann sind diese Werte ungleich.
Natürlich kann ich auch Bool-Werte selbst mit den Operatoren vergleichen.
True == True
# Wahr ist gleich Wahr -> Ausgabe: True
True != False
# Wahr ist nicht gleich Falsch -> Ausgabe: True
True == False
# Wahr ist gleich Falsch -> Ausgabe: FalseIch denke aber hier gibt es keine Überraschungen.
Verwechslungsgefahr – „=“ vs. „==“
Der Gleichheitsoperator verwendet in Python zwei Gleichzeichen (==). Das hat den Grund, dass das einfache Gleichzeichen bereits eine andere, sehr wichtige Funktion hat – als Zuweisungsoperator. Das sollte man nicht verwechseln.
Merke:
– Zwei Gleichzeichen (==) vergleichen ob zwei Werte identisch sind
– Ein Gleichzeichen (=) weist den Wert rechts vom Gleichzeichen der Variablen links vom Gleichzeichen zu
Als kleine Merkhilfe kann man den Nicht-Gleich-Operator nehmen. Dieser hat mit != ja zwei Zeichen. Deshalb braucht auch der Gleich-Operator zwei Zeichen (==) und nicht nur ein einfaches =.
Die <, >, <= und >= Operatoren funktionieren wirklich intuitiv nur mit Zahlen, also Ints und Floats.
100 < 120.4
# 100 ist kleiner als 120.4 -> Ausgabe: True
120.34 >= 1000
# 120.34 ist größer oder gleich 1000 -> Ausgabe: FalseBei Zahlen denke ich, dass man auch hier mit dem logischen Verstand alles richtig erfassen kann. Etwas verwirrend kann das Ganze sein, wenn man die Größer- und Kleiner-Operatoren in Verbindung mit Strings verwendet.
'Johannes' < 100
# Johannes ist kleiner als 100 -> Fehler: Strings und Zahlen können nicht mit diesen Operatoren verglichen werden
'Johannes' < 'Tim'
# Johannes ist kleiner als Tim -> Ausgabe: True
'alter' > 'Alter'
# alter ist größer als Alter -> Ausgabe: TrueZunächst können wir festhalten, dass wir Strings und Zahlen nicht mit diesen Operatoren vergleichen können. Das macht ja aber auch an sich wenig Sinn. Wenn wir zwei Strings vergleichen, dann funktioniert das, aber es ist nicht ganz eindeutig, was von Python hier evaluiert wird.
Jetzt kann man lange herumrätseln, aber es ist eigentlich simpel. Python vergleicht die Strings hier alphabetisch. In Zeile Vier beginnt der String Johannes mit einem J. Das kommt im Alphabet vor dem T mit dem der String Timothy beginnt, daher ist Johannes kleiner als Timothy.
Bei zwei fast identischen Strings ist offensichtlich, das kleine a in Zeile 7 größer als das große A. Die Reihenfolge bei Strings ist wie folgt:
- Als erstes kommen die Zahlen von 0-9
- Danach die Großbuchstaben A-Z
- Schließlich die kleinen Buchstaben a-z
Sind die ersten Zeichen des Strings identisch, geht Python immer weiter durch die Strings, bis eine Unterscheidung getroffen werden kann. Sind beide Strings bis zum Ende des einen Strings identisch, dann ist der kürzere String kleiner.
'Falte' < 'Fallen'
# Ausgabe: False
'Essen' > 'Ess'
# Ausgabe: TrueIm ersten Beispiel kommt das l vor dem t und daher ist Fallen kleiner. Im zweiten Beispiel sind alle vergleichbaren Buchstaben gleich. In diesem Fall ist der kürzere String Ess kleiner.
Bedingungen mit if-Statements in Python
Mit einem sogenannten if-Statement in Python kann ich abfragen, ob eine gewisse Bedingung erfüllt ist. Wenn das der Fall ist, wird der nachfolgende Code ausgeführt. Ansonsten wird der Code des if-Statements übersprungen und das Programm macht danach weiter. Dazu verwenden wir in Python sogenannte Blocks.
Blocks in Python
Für einige Elemente von Python (zum Beispiel if-Statements) müssen wir kommunizieren, dass bestimmter Code zusammengehört. Dazu verwenden wir den Einzug des zusammengehörigen Codes mit Tabstops oder Leerzeichen. Ein Block in Python wird folgendermaßen gebildet:
- Der Block beginnt dort, wo wir Text einrücken
- Der Block endet, wenn die Einrückung wieder entfernt wird
Sehen wir uns direkt ein einfaches if-Statement an, dann wird das sicherlich einfacher zu verstehen.
If-Statements in Python
Mit if-Statements im Programmieren haben wir ganz einfach gesagt eine Möglichkeit zu sagen:
„Führ diesen Code nur dann aus, wenn diese Bedingung erfüllt ist„
Ein if-Statement in Python wird folgendermaßen aufgebaut.
- Das Schlüsselwort if
- Eine Bedingung, die entweder zu True oder False ist
- Ein Doppelpunkt
- In der nächsten eingerückten Zeile der Code, der ausgeführt werden soll, wenn die Bedingung erfüllt ist
bedingung = True
if bedingung:
print('Die Bedingung ist wahr!')Die Bedingung ist wahr!
In Zeile Eins wird eine Variable mit dem Bool-Wert True definiert. Danach kommt unser if-Block. Wir beginnen mit dem Schlüsselwort if, das anzeigt wir wollen hier etwas überprüfen. Nach diesem if müssen wir dann eine Bedingung schreiben, die Python zu einem Bool-Wert evaluieren kann. In unserem Fall ist bedingung direkt eine Bool-Variable. Am Ende der Zeile schließen wir ab, indem wir einen Doppelpunkt schreiben.
Danach kommt unser Block: Durch die Einrückung von Zeile Vier zeigen wir an, dass dieser Code der Inhalt des if-Statements ist. Alles was hier eingerückt steht, wird nur dann ausgeführt, wenn die Bedingung des if-Statements erfüllt ist. In diesem Fall ist der Wert der Variablen bedingung True, also wird „Die Bedingung ist wahr!“ in der Konsole ausgegeben.
Hinweis zum Einzug
Es ist für Python im Prinzip egal, wie wir den Text für einen Block einrücken. Das bedeutet wir haben zwei Möglichkeiten: Leerzeichen oder Tabstops.
Ich persönlich bin aber ein starker Verfechter von Tabstops. Das hat einen einfachen Grund. Jede Zeile, die zu einem Block gehört muss genau gleich eingerückt werden. Das bedeutet, wenn ich zum Beispiel zwei Leerzeichen verwende, dann muss ich diese in jeder Zeile nutzen. Ein Leerzeichen zu viel oder zu wenig sorgt für einen Fehler.
Da ein einzelnes Leerzeichen aber oft kaum sichtbar ist, verwendet man in der Regel zwei oder mehr und schafft sich damit eine super Quelle für potenzielle Fehler.
Beim Tabstop dagegen kann ich immer einfach einen verwenden und das rückt mir den Text angenehm ein.
Ändern wir den Wert der Variablen, dann wird nichts aus dem if-Block ausgegeben.
bedingung = False
if bedingung:
print('Die Bedingung ist wahr!')
print('Das wird hier nicht ausgegeben.')
print('Diese Ausgabe steht nicht mehr im Block und wird daher immer in der Konsole erscheinen!')Diese Ausgabe steht nicht mehr im Block und wird daher immer in der Konsole erscheinen!
In diesem Fall ist die Bedingung des if-Statements nicht erfüllt, denn die Variable bedingung beinhaltet den Wert False. An der Ausgabe sieht man klar, dass nichts von den print()-Funktionen im if-Block ausgegeben wird.
In Zeile Sieben haben wir den Einzug zurückgesetzt und beginnen wieder am Anfang der Zeile zu schreiben. Daran erkennt Python eindeutig, dass dieser Code nicht mehr Teil des Blocks ist. Die Ausgabe der print()-Funktion wird daher immer in der Konsole erscheinen, egal ob bedingung den Wert True oder False hat.
Da wir schon Vergleichsoperatoren kennengelernt haben, können wir die Bedingung für unser if-Statement aber auch ein bisschen interessanter gestalten und nicht einfach direkt einen Bool-Wert verwenden.
name = 'Johannes'
if name == 'Johannes':
print('Hallo, Johannes')Hallo, Johannes
Hier haben wir nicht einfach direkt True oder False in der Bedingung geschrieben, sondern vergleichen zwei Werte. Es wird in Zeile Drei überprüft ob der Wert der Variablen name gleich Johannes ist. Wenn dieser Vergleich True liefert, dann wird das print()-Statement in Zeile 4 im Block ausgeführt.
Ein if-Statement ist schon ein wirklich nützliches Werkzeug, wenn man bestimmten Code nur dann ausführen will, wenn eben eine Bedingung erfüllt ist. Aber es gibt noch weitere Komponenten, die wir hier verwenden können, um das Ganze noch besser zu machen.
Else-Statements in Python
Ich kann Code also nur dann ausführen, wenn die Bedingung erfüllt ist. Aber was ist, wenn ich einen bestimmten anderen Code ausführen will, sollte die Bedingung nicht erfüllt sein? Für reine Bool-Werte könnte man das noch relativ einfach mit einem zweiten if-Statement lösen.
bedingung = True
if bedingung == True:
print('Die Bedingung ist erfüllt')
if bedingung == False:
print('Die Bedingung ist nicht erfüllt')Die Bedingung ist erfülltDa ein Bool überhaupt nur zwei Werte annehmen kann, reichen mir hier zwei if-Statements aus. Aber was ist, wenn ich beispielsweise etwas Bestimmtes ausgeben will für den Fall, dass ein Name Johannes ist und für alle anderen Fälle etwas anderes? Gar nicht mehr so leicht, den ein String kann ja unendlich viele andere Werte haben, die ich schlecht alle abfragen kann.
Dafür gibt es beim Programmieren die sogenannten else-Statements. Else gibt es in Python nur in Kombination mit if, in einem sogenannten If-Else Block. Dafür gelten die folgenden Regeln:
- Das Schlüsselwort else
- Ein Doppelpunkt
- In der nächsten eingerückten Zeile der Code, der ausgeführt werden soll, wenn die Bedingung des if-Teils nicht erfüllt ist
Das sieht im einfachsten Fall so aus.
bedingung = False
if bedingung:
print('Die Bedingung ist erfüllt')
else:
print('Die Bedingung ist nicht erfüllt')Die Bedingung ist nicht erfüllt
Man kann den if-Block also um einen optionalen else-Block ergänzen. Im Screenshot sieht man schön die Einrückung der zwei Blocks. Wir haben in Zeile 4 den Code des if-Blocks und in Zeile 6 den Code des else-Blocks.
Das Beispiel ist natürlich nicht besonders sinnvoll, aber mit if-else könnte man schon eine angepasste Begrüßung ausgaben, je nachdem, ob der Name bekannt ist oder nicht.
name = 'Johannes'
if name == 'Johannes':
print('Hey, Johannes')
else:
print('Hallo, Unbekannter')Hey, Johannes
Das können wir dann sogar noch verbessern, indem wir den else-Teil ergänzen und versuchen herauszufinden, wer denn der die mysteriöse Person ist.
name = 'Lisa'
if name == 'Johannes':
print('Hey, Johannes')
else:
print('Hallo, Unbekannter')
unbekannt = input('Was ist denn dein Name? ')
print('Na dann, hallo ' + unbekannt)Hallo, Unbekannter
Was ist denn dein Name? Lisa
Na dann, hallo Lisa
Wie man hier sieht, kann ich im Prinzip beliebig viele Zeilen Code in einen Block schreiben. Hier geben wir für den Fall, dass name nicht gleich Johannes ist erst einmal eine Begrüßung aus. Dann fragen wir mit der input()-Funktion den Namen ab und grüßen nochmal richtig.
Elif-Statements in Python
Wir kennen jetzt also if-Statements, die Code dann ausführen wenn eine Bedingung erfüllt ist. Außerdem haben wir else kennengelernt und können damit anderen Code ausführen, wenn die Bedingung nicht erfüllt ist. Einfach gesagt deckt das folgende Szenarien ab.
- Wenn das stimmt, mach das (einfaches if Statement)
- Wenn das stimmt, mach das, wenn nicht, mach das (if-else Statement)
Es gibt aber noch ein drittes Schlüsselwort, das wir verwenden können – elif.
Elif ist im Prinzip die abgekürzte Version von else if. Mit diesem Schlüsselwort können wir unseren Code ergänzen, um nacheinander verschiedene Bedingungen abzufragen.
- Wenn diese erste Bedingung erfüllt ist, führe den Code aus diesem Block aus
- Falls nicht -> Wenn diese zweite Bedingung erfüllt ist, führe den Code aus diesem Block aus
- Falls nicht -> Wenn diese dritte Bedingung erfüllt ist, führe den Code aus diesem Block aus
- …
- Optionales else am Ende: Wenn keine der Bedingungen erfüllt ist, führe den Code aus diesem Block aus
Sehen wir uns ein Beispiel an.
name = 'Leah'
if name == 'Johannes':
print('Hi, Johannes')
elif name == 'Timothy':
print('Hi, Timothy')
elif name == 'Leah':
print('Hi, Leah')
else:
print('Dich kenne ich nicht')
Hi, Leah
Mit elif können wir also nicht nur eine Bedingung testen. Sollte die erste Bedingung zu False evaluiert werden können wir weitere Bedingungen prüfen.
In unserem Beispiel haben wir ganz am Ende noch einen else-Teil hinzugefügt, der immer ausgeführt werden würde, wenn keine der if und elif Bedingungen True ergibt. Das ist aber optional. Gibt es keinen else-Teil am Ende und nichts ergibt True, dann wird einfach kein Code ausgeführt.
Außerdem ist es wichtig zu wissen, dass nicht alle Bedingungen geprüft werden. Sobald ein Teil des Ausdrucks bei der Bedingung True liefert, wird dieser Code ausgeführt und jeglicher Code in andern elif oder else Teilen wird nicht ausgeführt. Machen wir ein einfaches Beispiel.
zahl = 10
if zahl == 0:
print('Die Zahl ist Null')
elif zahl > 100:
print('Die Zahl ist größer als 100')
elif zahl > 0:
print('Die Zahl ist größer als Null')
elif zahl == 10:
print('Die Zahl ist Zehn')Die Zahl ist größer als Null
In diesem Fall wird „Die Zahl ist größer als Null“ ausgegeben, da das die erste Bedingung ist die erfüllt wird. Und obwohl die nächste Bedingung auch passen würde, da die Zahl 10 ist, wird das nicht mehr ausgegeben, denn das Statement hat eine gültige Bedingung gefunden und macht dann nach dem if-elif Block weiter.
