Python unter Linux: Kontrollstrukturen

Aus Wikibooks
Wechseln zu: Navigation, Suche

Bis jetzt sind Sie in der Lage, einfache Programme mit Ein- und Ausgabe und einfachen Berechnungen zu schreiben. Für größere Programme wird aber die Möglichkeit benötigt, Funktionen nur unter gewissen Bedingungen oder mehrfach durchzuführen. Für diesen Zweck gibt es die Kontrollstrukturen, nämlich bedingte Ausführung und Schleifen.

if[Bearbeiten]

Die if-Anweisung ist die einfachste Anweisung, mit der man abhängig von einer Bedingung eine Aktion auslösen kann:

#!/usr/bin/python

a = 0
if a < 1:
    print "a ist kleiner als 1"
Align=none Ausgabe

user@localhost:~$ ./if1.py
a ist kleiner als 1

Hier wird, wie in den ersten Schritten erläutert, eine Besonderheit von Python deutlich, nämlich die Einrückung. Alle gleich eingerückten Codezeilen gehören zum selben Block. Als Einrückungszeichen kann man Tabulatoren und Leerzeichen verwenden, wobei man niemals mischen sollte. Verwenden Sie vier Leerzeichen, wenn Sie konform zum Standard sein wollen.

#!/usr/bin/python
# -*- coding: utf-8 -*-

a = 0
if a < 1:
    print "a ist kleiner als 1"
    print "Dies gehört auch noch zum Block"
print "Dies gehört nicht mehr zur IF-Anweisung"
Align=none Ausgabe

user@localhost:~$ ./if2.py
a ist kleiner als 1
Dies gehört auch noch zum Block
Dies gehört nicht mehr zur IF-Anweisung

Selbstverständlich können Bedingung in der if-Anweisung auch zusammengesetzt werden:

#!/usr/bin/python
# -*- coding: utf-8 -*-

print "Bitte geben Sie eine Zahl ein:",
zahl = int(raw_input())

if zahl > 0 and zahl % 2 == 0:
    print "Gerade Zahl."
    if (90 <= zahl <= 100) or zahl == 50:
        print "Zahl ist zwischen 90 und 100 (inklusive), oder die Zahl ist 50"
Align=none Ausgabe

user@localhost:~$ ./if3.py
Bitte geben Sie eine Zahl ein: 22
Gerade Zahl.

Zusammengesetzte Anweisungen müssen nach logischen Regeln geklammert werden, die Einrückung muss angepasst werden.


Align=noneDetails

Einige Ausdrücke werden automatisch zu false ausgewertet, ohne dass wir extra darauf testen müssen. Dies betrifft:

  • das "Nichts-Objekt" None
  • die Konstante False
  • die Nullwerte aller nummerischen Typen, also z.B. 0, 0L, 0.0, 0j
  • den leeren String
  • das leere Tupel ()
  • die leere Liste []
  • das leere Dictionary {}
  • die leeren Mengen set() und frozenset()

Entsprechend werden Variablen "mit Inhalt" zu true ausgewertet.

if-elif-else[Bearbeiten]

Entscheidungen sind oft geprägt von mehreren Wahlmöglichkeiten, die man allesamt abfangen kann. Mit einer einfachen Fallunterscheidung wollen wir beginnen:

#!/usr/bin/python

print "Bitte geben Sie eine Zahl ein:",
a = int(raw_input())

if a % 2 == 0:
  print "%d ist gerade" % a
else:
  print "%d ist ungerade" % a
Align=none Ausgabe

user@localhost:~$ ./iee1.py
Bitte geben Sie eine Zahl ein: 12
12 ist gerade

Das Schlüsselwort else leitet den Codeblock ein, welcher Ausgeführt wird, wenn die Bedingung in der if-Anweisung nicht zutrifft.

Wählt man nun aus vielen verschiedenen Dingen aus, wie bei einer Mahlzeit im Restaurant, kommt man mit dieser recht trivialen Fallunterscheidung nicht weiter, es sei denn, man schachtelt sie. Python bietet mit elif eine weitere Möglichkeit an:

#!/usr/bin/python
# -*- coding: utf-8 -*-

print "Menü a la Carte:"
print "1 für Suppe"
print "2 für Sojaschnitzel mit Pommes"
print "3 Ich möchte nun zahlen"
print "Ihre Auswahl>",
auswahl = int(raw_input())

if auswahl == 1:
  print "Bitte sehr, Ihre Suppe"
elif auswahl == 2:
  print "Sojaschnitzel mit Pommes... bitte sehr."
elif auswahl == 3:
  print "Ihre Rechnung kommt sofort"
else:
  print "Das ist aber keine gute Wahl!"
Align=none Ausgabe

user@localhost:~$ ./iee2.py
Menü a la Carte:
1 für Suppe
2 für Sojaschnitzel mit Pommes
3 Ich möchte nun zahlen
Ihre Auswahl> 2
Sojaschnitzel mit Pommes... bitte sehr.

elif ist die Kurzschreibweise von else if. Die angehängte else-Anweisung wird nur dann ausgeführt, wenn keine vorherige Bedingung zutrifft.

if -- ganz kurz[Bearbeiten]

Es gibt eine einzeilige Variante der if-else-Kontrollstruktur. Die Syntax ist gedacht für Fälle, in denen in beiden Entscheidungszweigen derselben Variablen etwas zugewiesen werden soll, wie folgt:

#!/usr/bin/python

a = 22
text = ""
if a % 2 == 0:
    text = "gerade"
else:
    text = "ungerade"
print text

Die Syntax der Kurzschreibweise[1] ist anders als gewohnt, die Abfrage wird so zusagen in der Mitte vorgenommen:

#!/usr/bin/python

a = 22

text = "gerade" if a % 2 == 0 else "ungerade"
print text


Align=none Ausgabe

user@localhost:~$ ./ifkurz1.py
gerade

Der else-Zweig darf hierbei nicht entfallen.

Nur am Rande: Ein weiterer Weg, einen Einzeiler draus zu machen, kann mit folgender Notation erreicht werden.

#!/usr/bin/python
 
a = 22
 
text = ("gerade", "ungerade")[a % 2]
print text

Vergleichsoperatoren in der Übersicht[Bearbeiten]

Die folgende Tabelle zeigt die von Python unterstützten Vergleichsoperatoren.

Operator Beschreibung Beispiel Beispielausgabe
== Testet auf Werte-Gleichheit "Hallo" == "Welt" False
 != Testet auf Werte-Ungleichheit "Hallo" != "Welt" True
is Testet auf Objekt-Gleichheit type("Hallo") is str True
is not Testet auf Objekt-Ungleichheit type("Hallo") is not int True
< Testet auf kleineren Wert 4 < 4 False
<= Testet auf kleineren oder gleichen Wert 4 <= 4 True
> Testet auf größeren Wert "b" > "a" True
>= Testet auf größeren oder gleichen Wert 5.9 >= 6 False

Diese Vergleichsoperatoren können Sie mit Hilfe der logischen Operatoren aus dem Kapitel Datentypen, Boolean miteinander verknüpfen, um komplexere Ausdrücke zu formen.

Möchte man eine Variable darauf testen, ob sie innerhalb eines Intervalles liegt, kann man dies auf einfache Weise hinschreiben:

#!/usr bin/python
# -*- coding: utf-8 -*-

x = 4

if 10 > x >= 2:
    print "x ist kleiner als 10 und größer/gleich 2"
Align=none Ausgabe

user@localhost:~$ ./ifdoppelt.py
x ist kleiner als 10 und größer/gleich 2

Diese Syntax ist eine Kurzschreibweise von if x < 10 and x >=2.

for-Schleife[Bearbeiten]

for-Schleifen dienen dazu, einen Codeblock eine bestimmte Anzahl mal wiederholen zu lassen, wobei diese Anzahl zu beginn der Schleife feststeht. Hierbei wird über Sequenzen iteriert, es werden keine Variablen hochgezählt. Die Sequenz, über die iteriert wird, darf sich nicht zur Laufzeit ändern.

#!/usr/bin/python
# -*- coding: utf-8 -*-

for person in ["Herr Müller", "Frau Meier", "Tina Schulze"]:
    print person, "lernt Python!"
Align=none Ausgabe

user@localhost:~$ ./for1.py
Herr Müller lernt Python!
Frau Meier lernt Python!
Tina Schulze lernt Python!

Die Sequenz ist hier eine Liste, es könnte aber auch ein Tupel oder ein String sein. Manchmal möchte man einen Index mitlaufen lassen, der die Nummer eines Eintrages der Sequenz angibt. Dies ermöglicht uns die Funktion enumerate():

#!/usr/bin/python
# -*- coding: utf-8 -*-

for nummer, person in enumerate(["Herr Müller", "Frau Meier", "Tina Schulze"]):
    print "%s lernt als %d. Person Python!" % (person, nummer + 1)
Align=none Ausgabe

user@localhost:~$ ./for2.py
Herr Müller lernt als 1. Person Python!
Frau Meier lernt als 2. Person Python!
Tina Schulze lernt als 3. Person Python!

enumerate() liefert den Index wie auch den Eintrag bei jedem Schleifendurchlauf. Da wir die Personen von 1 durchzählen wollen, der Index jedoch bei 0 beginnt, haben wir die Ausgabe etwas angepasst.

Selbstverständlich funktionieren Schleifen auch mit der schon bekannten Funktion range(). Eine Variante dieser Funktion nennt sich xrange(Von, Bis, Step), wobei die Argumente Von und Step optional sind. Der Vorteil dieser Funktion liegt darin, dass ein solcher Wertebereich nicht als Liste im Speicher angelegt werden muss, Sie können also beliebig große Werte verwenden ohne Nachteile im Speicherverbrauch befürchten zu müssen:

#!/usr/bin/python
# -*- coding: utf-8 -*-

for zahl in xrange(0, 10, 2):
    print zahl, "ist eine gerade Zahl"
Align=none Ausgabe

user@localhost:~$ ./for3.py
0 ist eine gerade Zahl
2 ist eine gerade Zahl
4 ist eine gerade Zahl
6 ist eine gerade Zahl
8 ist eine gerade Zahl

Mit Hilfe der for-Schleife und einem Dictionary kann man die Häufigkeit von Zeichen einer Eingabe ermitteln:

#!/usr/bin/python
# -*- coding: utf-8 -*-

# Texteingabe
text = raw_input("Bitte geben Sie einen Text ein: ")
ergebnis = {}

# Anzahl der jeweiligen Zeichen bestimmen
for zeichen in text:
    ergebnis[zeichen] = ergebnis.get(zeichen, 0) + 1

# Anzahl der Zeichen insgesamt
anzahl_zeichen = len(text)
print "Es wurden", anzahl_zeichen, "Zeichen eingegeben, davon sind",

# Anzahl verschiedener Zeichen
anzahl = len(ergebnis)
print anzahl, "verschieden."

# Statistik der Zeichen ausdrucken
for key in ergebnis.keys():
    haeufigkeit = float(ergebnis[key]) / anzahl_zeichen * 100.0
    print "Das Zeichen '%s' kam %d mal vor. Häufigkeit: %4.1f%%" % \
            (key, ergebnis[key], haeufigkeit)
Align=none Ausgabe

user@localhost:~$ ./for4.py
Bitte geben Sie einen Text ein: Hallo, Welt
Es wurden 11 Zeichen eingegeben, davon sind 9 verschieden.
Das Zeichen 'a' kam 1 mal vor. Häufigkeit: 9.1%
Das Zeichen ' ' kam 1 mal vor. Häufigkeit: 9.1%
Das Zeichen 'e' kam 1 mal vor. Häufigkeit: 9.1%
Das Zeichen 'H' kam 1 mal vor. Häufigkeit: 9.1%
Das Zeichen 'l' kam 3 mal vor. Häufigkeit: 27.3%
Das Zeichen 'o' kam 1 mal vor. Häufigkeit: 9.1%
Das Zeichen ',' kam 1 mal vor. Häufigkeit: 9.1%
Das Zeichen 't' kam 1 mal vor. Häufigkeit: 9.1%
Das Zeichen 'W' kam 1 mal vor. Häufigkeit: 9.1%

ergebnis definieren wir als ein anfangs leeres Dictionary. Anschließend bestimmen wir, wie oft ein bestimmtes Zeichen eingegeben wurde. Hierzu bedienen wir uns der Methode get(), welche uns entweder die bisherige Anzahl eines eingegebenen Zeichens ausgibt oder 0 als voreingestellten Wert, wenn das Zeichen bisher nicht vorkommt. Die Häufigkeit eines Zeichens ist die Anzahl eines bestimmtes Zeichens geteilt durch die Gesamtzahl der Zeichen. Die Formatierung der print-Ausgabe ist hierbei noch ungewohnt. Die Formatanweisung %4.1f besagt, dass wir 4 Stellen der Zahl insgesamt ausgeben wollen, davon eine Nachkommastelle. Das doppelte Prozentzeichen hingegen bewirkt die Ausgabe eines einzelnen Prozentzeichens.

while-Schleife[Bearbeiten]

Ist die Anzahl der Schleifendurchläufe nicht von vorneherein fest, so bietet sich eine while-Schleife an. Mit dieser lässt sich das obige Restaurant-Beispiel so umschreiben, dass Gäste bestellen können, bis sie satt sind:

#!/usr/bin/python
# -*- coding: utf-8 -*-

satt = False
rechnung = 0

while not satt:
    print "Menü a la Carte:"
    print "1 für Suppe (2 Euro)"
    print "2 für Sojaschnitzel mit Pommes (4 Euro)"
    print "3 Ich möchte nun Zahlen"
    print "Ihre Auswahl>",
    auswahl = int(raw_input())
    if auswahl == 1:
        print "Bitte sehr, Ihre Suppe"
        rechnung += 2
    elif auswahl == 2:
        print "Sojaschnitzel mit Pommes... bitte sehr."
        rechnung += 4
    elif auswahl == 3:
        print "Ihre Rechnung beträgt %d Euro" % rechnung
        satt = True
    else:
        print "Das ist aber keine gute Wahl!"
Align=none Ausgabe

user@localhost:~$ ./while1.py
Menü a la Carte:
1 für Suppe (2 Euro)
2 für Sojaschnitzel mit Pommes (4 Euro)
3 Ich möchte nun Zahlen
Ihre Auswahl> 1
Bitte sehr, Ihre Suppe
Menü a la Carte:
1 für Suppe (2 Euro)
2 für Sojaschnitzel mit Pommes (4 Euro)
3 Ich möchte nun Zahlen
Ihre Auswahl> 2
Sojaschnitzel mit Pommes... bitte sehr.
Menü a la Carte:
1 für Suppe (2 Euro)
2 für Sojaschnitzel mit Pommes (4 Euro)
3 Ich möchte nun Zahlen
Ihre Auswahl> 3
Ihre Rechnung beträgt 6 Euro

Selbstverständlich können Sie den Schleifenkopf auf die gleiche Weise wie if-Anweisungen mit Bedingungen bestücken. Wichtig ist nur, dass die Schleife läuft, so lange die Bedingung im Schleifenkopf zu True ausgewertet wird.

break und continue[Bearbeiten]

Die beiden Schlüsselwörter break und continue brechen Schleifen ab oder führen an den Schleifenkopf zurück. Sie werden üblicherweise bei sehr großen Schleifenkörpern eingesetzt, wenn an einer Stelle deutlich wird, dass die aktuelle Iteration entweder die letzte ist oder der Rest des Schleifenkörpers unnötig ist und übersprungen werden soll. Man kann jede Schleife, die diese Schlüsselwörter enthält auch so umformulieren, dass diese nicht benötigt werden, jedoch führt ihr maßvoller Einsatz oft zu einem übersichtlicheren Code.

#!/usr/bin/python

while True:
  antwort = raw_input("Soll ich fortfahren? (J/N) ")
  if antwort in ('n', 'N'):
    break
Align=none Ausgabe

user@localhost:~$ ./break1.py
Soll ich fortfahren? (J/N) j
Soll ich fortfahren? (J/N) j
Soll ich fortfahren? (J/N) n

Hier wird der Schleifenkörper mindestens einmal ausgeführt. Man spricht in diesem Zusammenhang von einer nicht-abweisenden Schleife, da die Abbruchbedingung am Schleifenende[2] erfolgt. break kann aber selbstverständlich auch an jeder anderen Stelle innerhalb des Schleifenkörpers stehen.

#!/usr/bin/python

for buchstabe, zahl in [('a', 1), ('b', 2), (3, 3), ('d', 4)]:
    if type(buchstabe) is not str:
        continue
    else:
        print "Der Buchstabe", buchstabe, "hat den Zahlenwert", zahl
Align=none Ausgabe

user@localhost:~$ ./continue1.py
Der Buchstabe a hat den Zahlenwert 1
Der Buchstabe b hat den Zahlenwert 2
Der Buchstabe d hat den Zahlenwert 4

Das Tupel (3, 3) soll hier nicht ausgegeben werden. Der Vergleich auf Typengleichheit führt dazu, dass nur Zeichenketten und deren Werte ausgegeben werden. continue führt hier wieder zurück an den Schleifenanfang, wenn das erste Tupelelement keine Zeichenkette ist.

Schleifen-Else[Bearbeiten]

Schleifen können, wie Verzweigungen auch, ein else enthalten. Dieses wird bei for-Schleifen ausgeführt, wenn keine weiteren Iterationen mehr durchgeführt werden können, beispielsweise weil die zu iterierenden Liste abgearbeitet ist. Bei while-Schleifen wird der else-Block ausgeführt, wenn die Schleifenbedingung zu False ausgewertet wird. break führt bei Schleifen nicht(!) zu einem Übergang in den else-Block. Folgendes Beispiel zeigt einen Einsatzzweck von else bei einer for-Schleife:

#!/usr/bin/python
# -*- coding: utf-8 -*-


# user-UID-dict
users = {'anne' : 500, 'paul' : 501, 'martina' : 502}

print "Sucht nach einem Benutzernamen zu einer angegebenen UID."
uid = int(raw_input('Bitte geben Sie die UID ein: '))

for name in users.keys():
    if uid == users[name]:
        print "Die UID", uid, "gehört zu ", name
        break
else:
    print "Tut mir leid, es wurde kein passender Benutzername zu dieser UID gefunden."
Align=none Ausgabe

user@localhost:~$ ./forelse1.py
Sucht nach einem Benutzernamen zu einer angegebenen UID.
Bitte geben Sie die UID ein: 501
Die UID 501 gehört zu paul
...weiterer Aufruf...
Bitte geben Sie die UID ein: 1000
Tut mir leid, es wurde kein passender Benutzername zu dieser UID gefunden.

Das Programm sucht nach einem User, dessen User-ID angegeben wurde. Findet es diesen, so gibt es den Namen aus. Falls es keinen Benutzer mit dieser User-Id gibt, so wird der else-Block ausgeführt.

Das folgende Programm gibt den Hexdump einer Eingabe aus. Eine leere Eingabe beendet das Programm per break, das Wort Ende hingegen nutzt den else-Teil der Schleife:

#!/usr/bin/python

eingabe = ""
while eingabe != "Ende":
    eingabe = raw_input("Geben Sie etwas ein: ")
    if eingabe == "":
        break
    else:
        for c in eingabe:
            print hex(ord(c)),
        print
else:
    print "Das war es, vielen Dank"
Align=none Ausgabe

user@localhost:~$ ./whileelse1.py
Geben Sie etwas ein: Test
0x54 0x65 0x73 0x74
Geben Sie etwas ein: Ende
0x45 0x6e 0x64 0x65
Das war es, vielen Dank

Try-Except[Bearbeiten]

Im Zusammenhang mit Konvertierungen ist es uns schon bei den ersten Programmen aufgefallen, dass mal etwas schief gehen kann. Der Nutzer eines Programmes soll eine Zahl eingeben, gibt aber stattdessen seinen Namen ein. Schon bricht Python die Verarbeitung ab:

#!/usr/bin/python

x = int(raw_input("Bitte geben Sie eine Zahl ein: "))
print x
Align=none Ausgabe

user@localhost:~$ ./except1.py
Bitte geben Sie eine Zahl ein: Zehn
Traceback (most recent call last):
  File "./except1.py", line 3, in <module>
    x = int(raw_input("Bitte geben Sie eine Zahl ein: "))
ValueError: invalid literal for int() with base 10: 'Zehn'

Python kennt hier eine Möglichkeit, einen Codeblock probeweise auszuführen und zu schauen, ob die Abarbeitung erfolgreich ist. Ist sie es nicht, wird eine so genannte Exception ausgelöst, die Bearbeitung des Codeblockes wird abgebrochen und zu einer Stelle im Code gesprungen, die diesen Fehler abfängt:

#!/usr/bin/python

try:
    x = int(raw_input("Bitte geben Sie eine Zahl ein: "))
    print x
except:
    print "Ein Fehler ist aufgetreten, macht aber nichts!"
print "Hier geht es weiter"
Align=none Ausgabe

user@localhost:~$ ./except2.py
Bitte geben Sie eine Zahl ein: Zehn
Ein Fehler ist aufgetreten, macht aber nichts!
Hier geht es weiter

Was immer nun der Nutzer eingibt, er bekommt auf jeden Fall eine Ausgabe. Die Anweisung, welche die Zahl ausgeben soll wird jedoch nur ausgeführt, wenn die Konvertierung erfolgreich war. War sie es nicht, wird der Codeblock unterhalb von except abgearbeitet. In jedem Fall wird die letzte print-Anweisung ausgeführt.

Wird statt einer Zahl ein Buchstabe versuchsweise konvertiert, gibt es einen so genannten ValueError, den Sie gesehen haben, als Sie das erste Beispiel dieses Abschnitts mit Buchstabendaten ausgeführt haben. einige der Exceptions kann man gezielt abfangen, wie folgendes Beispiel demonstriert:

#!/usr/bin/python

try:
  x = int(raw_input("Bitte geben Sie eine Zahl ein: "))
  print x
except ValueError:
  print "Das war keine Zahl!"
except:
  print "Irgendein anderer Fehler"
Align=none Ausgabe

user@localhost:~$ ./except3.py
Bitte geben Sie eine Zahl ein: Zehn
Das war keine Zahl!

Geben Sie nun eine Buchstabenfolge ein, wird der Block unterhalb except ValueError ausgeführt. Um einen anderen Fehler zu provozieren, geben Sie STRG+C ein, es wird dann der Block ausgeführt, der die allgemeine Exception bearbeitet.

Try-Finally[Bearbeiten]

Für manche schweren Fehler reicht except nicht aus, das Programm muss abgebrochen werden. In diesem Fall ermöglicht uns finally, noch letzte Aufräumarbeiten durchzuführen, wie zum Beispiel eine Datei zu schließen oder schlicht einen Grund für das Scheitern anzugeben:

#!/usr/bin/python
# -*- coding: utf-8 -*-

try:
  x = 1 / 0
  print x
finally:
  print "Oh, eine Division durch Null! Ich räume noch eben auf..."
print "Hierhin komme ich nicht mehr!"
Align=none Ausgabe

user@localhost:~$ ./finally1.py
Oh, eine Division durch Null! Ich räume noch eben auf...
Traceback (most recent call last):
  File "./finally1.py", line 5, in <module>
    x = 1 / 0
ZeroDivisionError: integer division or modulo by zero

Die letzte Zeile des Codes wird nie erreicht. Nach der Division durch Null wird eine Exception geworfen, die Meldung ausgegeben und der Programmlauf abgebrochen. finally wird immer ausgeführt, auch dann, wenn kein Fehler auftrat. Darauf können wir uns verlassen. Man kann try-except und try-finally gemeinsam verwenden, wie folgendes Beispiel zeigt:

#!/usr/bin/python
# -*- coding: utf-8 -*-

print "Berechnet die Zahl 1/x "
wert = 0
try:
  x = raw_input("Geben Sie eine Zahl ein: ");
  wert = 1.0 / float(x)
except ValueError:
  print "Fehler: Das war keine Zahl"
except KeyboardInterrupt:
  print "Fehler: Steuerung-C gedrückt"
finally:
  print "Danke für die Zahl"

print wert

Hier können Sie Fehler produzieren, in dem Sie STRG+C, Buchstaben oder 0 eingeben. In jedem Fall wird der Programmteil ab finally ausgeführt.

Assert[Bearbeiten]

Mit assert(Bedingung) machen Sie Zusicherungen, die im weiteren Verlauf des Programmes gelten. Sollten diese Zusicherungen nicht erfüllt sein, die Bedingung also zu False ausgewertet werden, wird eine Exception geworfen und das Programm bricht ab, wie folgendes Beispiel zeigt:

#!/usr/bin/python


text = raw_input("Bitte geben Sie Text ein: ")
assert(text != "")
print text

Wenn Sie beim Programmlauf keine Eingabe machen, sondern nur mit Return bestätigen, erhalten Sie folgende Ausgabe:

Align=none Ausgabe

user@localhost:~$ ./assert1.py
Bitte geben Sie Text ein:
Traceback (most recent call last):
  File "./a.py", line 5, in <module>
    assert(text != "")
AssertionError

Hier wird eine Exception geworfen, das Programm bricht ab. Solche Zusicherungen baut man überall dort in Programme ein, wo es unsinnig wäre, ohne diese Zusicherung fortzufahren.

Zusammenfassung[Bearbeiten]

In diesem Kapitel haben Sie gelernt, wie Sie den Ablauf von Programmen steuern und beeinflussen können. Steuerungsmöglichkeiten sind das Verzweigen und wiederholte Ausführen von Programmteilen. Ebenfalls können Sie nun Fehler abfangen und notwendige Arbeiten kurz vor dem unvermeidlichen Ende ihres Programmes durchführen lassen.

Anmerkungen[Bearbeiten]

  1. Diese Notation ist einzigartig und insbesondere verschieden von dem in der Programmiersprache C bekannten Bedingungsoperator, bei dem die Bedingung der Zuweisung vorhergeht:
    char* text = a % 2 == 0 ? "gerade" : "ungerade";
    
    
  2. In C/C++/Java ist dies analog zu einer do...while(bedingung)-Schleife