Programmablauf

Wir wollen hier die grundlegenden Konzepte zu Programmabläufen vorstellen, die in nahezu jeder Programmiersprache vorkommen.
Um einen logischen Programmablauf zu realisieren, benötigen wir Fallunterscheidungen und Schleifen.
Ferner lernen wir, eigene Funktionen zu implementieren, um den Programmablauf besser zu strukturieren und häufig verwendete Codezeilen auszulagern.

Logische Operatoren¶

Logische Operatoren werden in if-Abfragen und Schleifen verwendet um den Programmablauf zu steuern:

Vergleichsoperationen geben immer ein Objekt vom Typ bool zurück, also entweder True oder False:

Vergleichsoperatoren können allerdings nur dann verwendet werden, wenn diese Operationen auch für die zu vergleichenden Datentypen definiert ist. Folgende Vergleiche funktionieren:

##de Bei komplexen Zahlen existiert keine Vergleichsoperation wie < oder >:

Boolsche Ausdrücke können auch miteinander verknüpft werden. Die Äquivalente der mathematischen Ausdrücke $a\wedge b$, $a\vee b$ und $\neg a$ sind:

Beispiel: Wir wollen testen, ob eine Zahl $x$ im Intervall $[1/4,3/4)$ liegt:

Fallunterscheidungen (if-Abfragen)¶

Fallunterscheidungen können in Python wie folgt realisiert werden:

if <condition_1>:
    # Wenn condition_1 True ist:
    [do something]
    ...
    [do something more]
elif <condition_2>:
    # Wenn condition_1 False und condition_2 True ist:
    [do something]
    ...
    [do something more]
else:
    # Wenn condition_1 und condition_2 False sind:
    [do something]
    ...
    [do something more]

Natürlich kann die Abfrage um beliebig viele elif-Blöcke erweitert werden. condition_1 und condition_2 müssen hier bool’sche Variablen, also entweder True oder False sein. Die Einrückung des unter der if-Anweisung stehenden Codes bestimmt was bei Gültigkeit von condition_1 alles getan wird. Der Codeblock, der jeweils ausgeführt wird endet bei der letzten eingerückten Zeile. Beachte dazu die Ausgabe folgendes Codes:

In folgendem Beispiel wird eine Zufallszahl zwischen 1 und 10 erzeugt und getestet, ob es sich um eine gerade oder ungerade Zahl handelt. Dazu lernen wir gleich auch den sogenannten Modulo-Operator % kennen, welcher den Divisionsrest bei Division zweier ganzer Zahlen zurückgibt. Beispiel: 8%3 ergibt 2, da $8=2\cdot 3+\textbf{2}$. Dies wird 10 mal wiederholt. Eine Erläuterung zu for-Schleifen folgt im nächsten Abschnitt.

Schleifen¶

for-Schleifen¶

Um die Notwendigkeit von Schleifen zu verstehen, betrachten wir zunächst folgenden Code, in dem die Summe von Zahlen aus einer Liste berechnet wird:

Wir wollen hier offensichtlich alle Elemente einer Liste durchgehen. Problematisch wird es dann, wenn die Liste mehrere Tausend Elemente beinhaltet. Unser Code würde dann auf mehrere Tausend Zeilen anwachsen. Zudem haben wir hier ausgenutzt, dass wir bereits die Anzahl der Elemente in der Liste kennen. Die Zeilen value += a[i] unterscheiden sich lediglich im Index i und mit Schleifen lassen sich all diese Zeilen zusammenfassen.

Die erste Art von Schleifen, die wir hier diskutieren möchten, ist die for-Schleife. Die allgemeine Syntax lautet:

for <elem> in <iterable_object>:
    [do something]
    ...
    [do something more]

• <iterable_object> kann jede Art von Objekt sein, das einen Iterator bereitstellt (mehre dazu in Abschnitt Iteratoren)

• Beispiele: Liste, ein Tupel oder Numpy-Array (siehe Abschnitt Lineare Algebra mit NumPy), String

Das obige Beispiel lässt sich mit einer for-Schleife vereinfachen:

Hier wird die Zeile value += elem so oft wiederholt, wie die Liste Elemente enthält. Die Variable elem nimmt nacheinander die Werte a[0], a[1], ..., a[4] an.

Neben den oben genannten iterierbaren Datentypen gibt es noch die Klasse range. Ein Range-Objekt repräsentiert ein Intervall für den Iterationsindex mit Start- und Endindex. Aus der Python-Dokumentation (zugänglich via range?) erfahren wir beispielsweise

range(stop) -> range object
range(start, stop[, step]) -> range object

Return an object that produces a sequence of integers from start (inclusive)
to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
start defaults to 0, and stop is omitted!

Hier ein kleiner Test:

Merke: Falls vor dem ersten Schleifendurchlauf bereits die Anzahl der Schleifendurchläufe feststeht, sollte eine for-Schleife verwendet werden. Andernfalls, eine while-Schleife, welche wir im folgenden Abschnitt diskutieren.

Scheifen können mit den Befehlen continue und break innerhalb des Schleifenblocks weiter beeinflusst werden. Mit break lässt sich ein weiteres Abbruchkriterium einbauen. Im Beispiel wird in einer Liste die Zahl 5 gesucht und beim ersten Auftauchen dieser Zahl wird die Schleife unterbrochen.

Im vorherigen Beispiel wird die Schleife nach dem Auftauchen der Zahl 5 mit break abgebrochen - sie wird also nach dem dritten Durchlauf nicht weiter ausgeführt.

Im Gegensatz dazu unterbricht continue nur den aktuellen Schleifendurchlauf und springt direkt zum nächsten Durchlauf.

Beispiel: Berechne die Summe aller geraden Zahlen von 1 bis 10:

while-Schleifen¶

Bei for-Schleifen war das Abbruchkriterium bereits vor dem ersten Schleifendurchlauf bekannt.
Ändert sich das Abbruchkriterium während der Schleife, verwendet man while-Schleifen.
Die allgemeine Syntax lautet:

while <condition>:
    [do something]
    ...
    [do something more]

• <condition> ist ein bool’scher Ausdruck.

• Der eingerückte Schleifenblock wird so lange ausgeführt, wie <condition> True ist.

• Damit keine Endlosschleife entsteht, muss sichergestellt werden, dass <condition> nach endlich vielen Durchläufen False wird.

In folgendem Beispiel werden so lange Zufallszahlen erzeugt, bis eine durch 5 teilbare Zahl erzeugt wurde:

Auch bei while-Schleifen wirken die Befehle continue und break.

Funktionen¶

Eigene Funktionen definieren¶

Oft wiederverwendete Programmbestandteile können zur besseren Lesbarkeit des Programmcodes in Funktionen ausgelagert werden. Eine Funktion muss vor ihrem ersten Aufruf definiert werden.

Die allgemeine Syntax einer Funktionsdefinition lautet

def <function_name>(<param1>, <param2>[, ...]):
    [do something]
    ...
    [do something more]
    return <ret1>, <ret2>[, ...]

Die Parameter der Funktion <param1>, <param2> etc. werden beim Funktionsaufruf übergeben. Die Rückgabewerte <ret1>, <ret2> usw. werden von der Funktion zurückgegeben und können beispielsweise als Tupel gespeichert werden. Falls die Funktion keine Werte zurückgeben soll, beispielsweise bei einer Funktion welche nur etwas auf der Konsole ausgeben soll, kann die Zeile mit return auch weggelassen werden.

Beachte: Beim Aufruf von return wird die Funktion sofort verlassen. Eventuell nachfolgender Programmcode innerhalb der Funktion wird dann nicht mehr ausgeführt.

Die Syntax eines Funktionsaufrufs lautet

<ret1>, <ret2>[, ...] = <function_name>(<param1>, <param2>[, ...])

Wir beginnen mit einem einfachen Beispiel. Die folgende Funktion summiert alle Elemente eines iterierbaren Objekts L auf und gibt das Ergebnis zurück:

Um diese Funktion nun auszuführen schreiben wir:

Beachte, dass wir unsere Funktion sum mit Parametern eines beliebigen Typs aufrufen können, für den alle in sum verwendeten Operationen definiert sind.

Unsere Summenfunktion lässt sich daher auch mit Tupeln aufrufen:

Nicht jedoch mit Strings. Strings sind zwar ebenfalls iterierbar, was die Verwendung in einer for-Schleife erlaubt, aber die Operation += zwischen einem Integer (beachte: val ist aufgrund der Zeile val = 0 ein Integer) und einem String ist nicht definiert:

Lokale und globale Variablen¶

Zu beachten ist, dass alle Variablen, die innerhalb einer Funktion definiert werden, lediglich lokale Variablen sind. Sie sind also außerhalb der Funktion nicht sichtbar.

Existiert bereits eine globale Variable mit demselben Namen, so wird innerhalb der Funktion nur mit der lokalen Variable gearbeitet:

Im letzten Beispiel wurde erst durch die Zeile value = ... die lokale Variable value angelegt.

Fehlt diese Zeile, beispielsweise in einer Funktion, die den Wert von value nur lesen, aber nicht verändern soll, dann wird innerhalb der Funktion die globale Variable mit demselben Namen verwendet:

Möchte man eine globale Variable innerhalb einer Funktion verändern, muss man zu Beginn der Funktion klarstellen, dass keine neue lokale Variable angelegt werden soll. Dies geschieht mit dem Schlüsselwort global:

Diese Variante sollte man jedoch nach Möglichkeit vermeiden. Andere Funktionen verlassen sich möglicherweise darauf, dass sich der Wert der globalen Variablen nicht unerwartet ändert.

1. Welche Ausgabe erzeugt dieses Programm?

2. Erkläre, warum sich der Wert der globalen Variable value nicht verändert.

3. Ändere die Funktion so, dass die globale Variable tatsächlich verändert wird.

Mutable vs. Immutable¶

Eine weitere interessante Frage ist: Was passiert mit Funktionsparametern, wenn wir sie innerhalb einer Funktion verändern?
Die Antwort liefert ein einfacher Test:

Obwohl wir a also in der Funktion verändern haben, ändert sich der Wert von a außerhalb der Funktion nicht.

Das liegt daran, dass beim Aufruf der Funktion add_something eine Kopie der Referenz auf den Wert von a übergeben wird. Da a ein immutabler Datentyp (Integer) ist, führt die Operation a += 5 dazu, dass ein neues Objekt erzeugt wird, auf das nur die lokale Variable a innerhalb der Funktion zeigt.

Jetzt wird es allerdings etwas verwirrend. Im folgenden Beispiel ist der Funktionsparameter eine Liste, die innerhalb der Funktion verändert wird. Wenn innerhalb der Funktion nur mit einer Kopie gearbeitet wird, sollte sich die Liste L nach dem Funktionsaufruf eigentlich nicht geändert haben. Dies ist jedoch offensichtlich nicht der Fall:

Offensichtlich wurde innerhalb von append_something nicht mit einer Kopie der Liste gearbeitet, sondern direkt mit dem Objekt L.

Um dieses Verhalten zu verstehen, hilft ein genauerer Blick auf die Funktionsweise von Variablen in Python. Variablen sind Bezeichner für Objekte im Speicher.

Mit der Funktion id, welche eine Identifikationsnummer eines Objekts zurückgibt, können wir uns anschauen, wo der Wert einer Variablen im Speicher abgelegt ist. Im folgenden Beispiel legen wir zwei Variablen an, die offensichtlich dieselbe ID besitzen:

Dies kann so interpretiert werden, dass a und b im Prinzip nur Namen sind, welche wir an ein Objekt binden (hier die Konstante 5, die irgendwo im Speicher liegt).

Am Anfang zeigen sowohl a als auch b auf dasselbe Objekt im Speicher. Deshalb liefern id(a) und id(b) die gleiche Identifikationsnummer und der Ausdruck a is b ergibt True.

Wird anschließend der Wert von b verändert (b = b + 1), dann passiert Folgendes:

1. Es wird ein neues Objekt mit dem Wert 6 erzeugt.

2. Der Name b wird an dieses neue Objekt gebunden.

3. a bleibt weiterhin an das ursprüngliche Objekt 5 gebunden.

Das ursprüngliche Objekt im Speicher wird also nicht verändert, sondern es entsteht ein neues Objekt.

Implementieren wir einen ähnlichen Test für Listen-Objekte:

Hier sind a und b zwar Listen mit genau dem gleichen Inhalt, die Namen zeigen aber auf verschiedene Objekte im Speicher. Das erkennt man daran, dass id(a) und id(b) unterschiedliche Werte liefern und der Ausdruck a is b False ergibt.

Im Gegensatz zu den vorher betrachteten Integers wird hier also für jede Liste ein neues Objekt erzeugt, auch wenn der Inhalt identisch ist.

Wir verändern das Beispiel leicht:

Durch die Zuweisung b=a haben wir b an das gleiche Objekt wie a gebunden. Und nun müssen wir aufpassen. Wir haben lediglich das Objekt hinter b durch b.append(4) verändert, da a und b aber an die gleichen Objekte gebunden sind hat diese Operation auch a verändert. Die Position des Objektes im Speicher hat sich dabei nicht verändert. Damit ist das Objekt selbst also veränderbar.

Wie unsere Beispiele gezeigt haben ist ein Objekt vom Typ int immutable, was bedeutet, dass dieses nicht verändert werden kann. Verändert man den Wert eines Integers, so wird ein neues Objekt erzeugt an den der ursprüngliche Name gebunden wird:

Listen sind hingegen mutable (veränderlich) und verhalten sich anders:

Dies erklärt auch das unterschiedliche Verhalten bei der Verwendung von Listen als Funktionsparameter. Das Verhalten bei immutable (veränderlichen) Datentypen erklärt sich leicht, wenn wir unser Beispiel von oben um einige Ausgaben ergänzen:

Der Name a ist zunächst an das Objekt mit der Konstanten 1 gebunden. Der Name wird an die Funktion add_something übergeben, heißt nun a_ (zur besseren Unterscheidung, wir hätten es auch weiterhin a nennen können), ist aber immer noch an das gleiche Objekt gebunden. Innerhalb der Funktion wird nun eine Operation auf dieses Objekt angewendet, hier +=. Dabei wird eine Kopie erstellt, da Integer immutable sind, und der Name a_ zeigt auf dieses neue Objekt, welches die Konstante 2 beinhaltet. Der Name a außerhalb der Funktion add_something ist allerdings weiter an das alte Objekt gebunden und bleibt dadurch unbeeinflusst von dem, was innerhalb der Funktion passiert.

Wäre a im vorherigen Beispiel eine Liste, also ein mutable Objekt, würde sich bei einer Operation, die die Liste verändert, die Bindung des Namens an das Objekt nicht ändern.

Fazit:

• Immutable Objekte (int, float, string, tuple) → Änderungen erzeugen neue Objekte.

• Mutable Objekte (list, dict, set, …) → Änderungen wirken sich direkt auf das übergebene Objekt aus.

Rekursive Funktionen¶

Rekursive Funktionen sind Funktionen, welche sich, bis zu einem bestimmten Abbruchkriterium, immer wieder selbst aufrufen. Ein typisches Beispiel wäre folgende Funktion zur Berechnung der Fakultät:

Beachte, dass viele Algorithmen sowohl rekursiv, als auch iterativ (mit einer Schleife) realisierbar sind. Aus Effizienzgründen ist in diesem Fall immer die iterative Variante zu bevorzugen.