Beschreiben Sie in 2-3 Stichpunkten kurz was Sie im Seminar heute lernen wollen. Klicken Sie dazu doppelt auf diesen Text und bearbeiten Sie dann den Text:
-
-
-
## Exkurs: Was mir an Python gefällt
In dieser Rubrik, die immer am Anfang eines Kapitels steht, möchte ich Ihnen zeigen, wofür ich Python nutze und warum ich es mag. Sie werden vielleicht noch nicht verstehen, was ich genau mache, aber Sie sehen damit schon einmal die Möglichkeiten von Python und können später darauf zurückgreifen. Da dies auch ein Exkurs ist, können Sie diese Rubrik gerne auch erst einmal überspringen.
Es ist sehr leicht, Ergebnisse mit Hilfe eines Plots darzustellen und auch mathematische Funktionen können professionell geplottet werden:
%% Cell type:code id: tags:
```
%matplotlib inline
import math
import matplotlib.pyplot as pyplot
# sin(x) und cos(x) zwischen 0 und 2pi
x = [xx/10 for xx in range(0,int(2*math.pi*10))]
sinx = [math.sin(xx) for xx in x]
cosx = [math.cos(xx) for xx in x]
pyplot.plot(x, sinx, label='sin(x)')
pyplot.plot(x, cosx, label='cos(x)')
pyplot.grid(linestyle="dashed")
pyplot.legend()
```
%% Cell type:markdown id: tags:
## 3: Funktionen
**Funktionen** bezeichnen eine benannte Folge von Anweisungen. Wenn wir eine Funktion definieren, dann geben wir den Namen der Funktion an und die Folge von Anweisungen. Später können wir die Funktion dann mit ihrem Namen **aufrufen**.
### Warum?
Warum ist es sinnvoll, ein Programm in Funktionen aufzuteilen?
-**Lesbarkeit** - z.B. weil eine Folge von Anweisungen dann einen Namen trägt der beschreibt, was sie tun
-**Fehlersuche** - z.B. weil Fehler innerhalb einer Funktion den Suchbereich einschränken
-**kürzerer Programmkode** - z.B. weil sich Quellcode nicht wiederholt
-**Wartbarkeit** - z.B. weil wir Änderungen nur an einer Stelle durchführen müssen
-**Testbarkeit** - z.B. wir jede Funktion einzeln testen können
-**Wiederverwendbarkeit** - weil eine gut funktionierende Funktion in vielen Programmen verwendet werden kann.
%% Cell type:markdown id: tags:
### Funktionsaufrufe
Wir haben schon einige Funktionsaufrufe gesehen:
%% Cell type:code id: tags:
```
type(42)
```
%% Cell type:markdown id: tags:
Der Name der Funktion ist `type`, der Ausdruck innerhalb der Klammern ist das **Argument** der Funktion. Das Ergebnis dieser Funktion ist der Typ des Arguments.
Üblicherweise sagen wir, dass eine Funktion ein Argument "erwartet" und ein Ergebnis "zurückgibt". Dieses Ergebnis wird auch **Rückgabewert** genannt.
Python stellt einige Funktionen bereit, um Werte von einem Datentyp zu einem anderen umzuwandeln. Beispielsweise erwartet die `int`-Funktion einen Wert als Argument, den sie dann in eine ganze Zahl umwandelt - falls möglich (andernfalls beschwert sie sich und gibt einen Fehler aus):
%% Cell type:code id: tags:
```
int('32')
```
%% Cell type:code id: tags:
```
int('wassolldas?')
```
%% Cell type:markdown id: tags:
Mit Hilfe der `int`-Funktion können wir zum Beispiel Fließkommazahlen in ganze Zahlen umwandeln:
%% Cell type:code id: tags:
```
int(32.7)
```
%% Cell type:markdown id: tags:
Allerdings wird dabei der Teil hinter dem Dezimalpunkt abgeschnitten und nicht gerundet:
%% Cell type:code id: tags:
```
int(-2.2)
```
%% Cell type:markdown id: tags:
Analog dazu können wir mit der `float`-Funktion ganze Zahlen und Zeichenketten in Fließkommazahlen umwandeln:
%% Cell type:code id: tags:
```
float(6)
```
%% Cell type:code id: tags:
```
float('32.2')
```
%% Cell type:markdown id: tags:
Und schließlich wandelt die `str`-Funktion Zahlen in Zeichenketten um:
%% Cell type:code id: tags:
```
str(42)
```
%% Cell type:code id: tags:
```
str(3.1415923)
```
%% Cell type:markdown id: tags:
Hinweis: Anfangs hatten wir die Gänsefüßchen als "Markierung" für Zeichenketten kennengelernt. Es ist auch möglich, Zeichenketten mit einfachen Hochkommata (') einzuschließen - so wie das Python hier gemacht hat. Das ermöglicht uns z.B., Sätze mit indirekter Rede ('Da sagte er "heute wird es regnen" und ging ab.') als Zeichenkette auszudrücken. Umgekehrt können wir mit Hilfe der Gänsefüßchen Sätze wie "Das wär's gewesen." einschließen. Probieren Sie beides aus, indem Sie die beiden Sätze jeweils einer Variablen zuweisen und dann mit der `print`-Anweisung ausgeben:
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
### Mathematische Funktionen
Mit Python wird ein Mathematik-Modul mitgeliefert, das die üblichen mathematischen Funktionen enthält. Ein **Modul** ist eine Datei, die eine Sammlung von verwandten Funktionen enthält.
Exkurs: Oft sagt man statt Modul auch *Bibliothek*. Einen Überblick über die mitgelieferten "Standardbibliotheken" finden Sie hier: https://docs.python.org/3.5/library/. Es gibt z.B. Module zur [Datumsberechnung](https://docs.python.org/3.5/library/datetime.html), für [Datenbankzugriffe](https://docs.python.org/3.5/library/sqlite3.html), für [Datenkomprimierung](https://docs.python.org/3.5/library/gzip.html), [Verschlüsselung](https://docs.python.org/3.5/library/ssl.html) und [Netzwerkzugriffe](https://docs.python.org/3.5/library/socket.html). Einige dieser Module werden wir vielleicht noch kennenlernen. Zusätzlich gibt es tausende Module im Web, die wir uns herunterladen und installieren können.
Wir können ein Modul mit Hilfe der **import-Anweisung** einbinden:
%% Cell type:code id: tags:
```
import math
```
%% Cell type:markdown id: tags:
Ab jetzt stehen uns die Funktionen des `math`-Moduls zur Verfügung und zwar als sogenanntes **Modulobjekt**. Wir können uns das Modulobjekt "anschauen":
%% Cell type:code id: tags:
```
math
```
%% Cell type:markdown id: tags:
Hilfreicher ist es allerdings, das Modulobjekt der Funktion `help` zu übergeben:
%% Cell type:code id: tags:
```
help(math)
```
%% Cell type:markdown id: tags:
Im Modulobjekt sind Funktionen und Variablen enthalten, die in der Moduldatei definiert wurden. Um auf eine der Funktionen oder Variablen zuzugreifen, müssen wir den Namen des Moduls angeben und den Namen der Funktion (oder Variable), getrennt durch einen Punkt:
%% Cell type:code id: tags:
```
math.sin(3)
```
%% Cell type:markdown id: tags:
Dies gibt beispielsweise den Wert der Sinus-Funktion an der Stelle 3 aus. Dieses Format heißt **Punkt-Schreibweise** (Englisch: *dot notation*) und wird uns öfter begegnen.
Ein weiteres Beispiel ist der Wert von π, der im `math`-Modul definiert ist:
%% Cell type:code id: tags:
```
math.pi
```
%% Cell type:markdown id: tags:
Der Wert ist in der Variablen `pi` im `math`-Modul definiert, auf die wir mit Hilfe der Punkt-Schreibweise zugreifen können.
%% Cell type:markdown id: tags:
### Verknüpfung
Bisher haben wir uns die Elemente von Programmen - Variablen, Ausdrücke, Anweisungen - einzeln angeschaut aber nicht groß darüber gesprochen, wie wir sie kombinieren können.
Eine der nützlichsten Eigenschaften von Programmiersprachen ist, dass wir kleinere Bausteine miteinander **verknüpfen** (Englisch: *compose*/*composition*) können. Beispielsweise kann das Argument einer Funktion jeglicher Ausdruck sein, einschließlich arithmetischer Operatoren
%% Cell type:code id: tags:
```
degrees = 120
x = math.sin(degrees / 360.0 * 2 * math.pi)
```
%% Cell type:markdown id: tags:
und sogar Funktionsaufrufe:
%% Cell type:code id: tags:
```
x = math.exp(math.log(2 + math.pi))
```
%% Cell type:markdown id: tags:
Versuchen Sie es selber einmal: Verketten Sie die Zeichenkette `"Der Typ des Ausdrucks 27 + 3 ist: "` mit dem Aufruf der Funktionsverknüpfung `str(type(27+3))` und geben Sie das Ergebnis mit der `print`-Funktion aus:
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
Fast überall, wo wir einen Wert verwenden können, können wir auch einen beliebigen Ausdruck einsetzen:
%% Cell type:code id: tags:
```
gesamt = degrees * 20 # richtig
20 * degrees = gesamt # falsch!
```
%% Cell type:markdown id: tags:
Die linke Seite einer Zuweisung muss *immer* ein Variablenname sein! Jeglicher anderer Ausdruck auf der linken Seite ergibt einen Syntaxfehler. (Ausnahmen bestätigen die Regel ... aber dazu später.)
%% Cell type:markdown id: tags:
### Neue Funktionen hinzufügen
Bisher haben wir nur Funktionen genutzt, die bei Python schon "mitgeliefert" werden. Es ist aber auch möglich, eigene Funktionen hinzuzufügen. Eine **Funktionsdefinition** gibt den Namen der Funktion an und eine Folge von Anweisungen, die ausgeführt werden, wenn die Funktion ausgeführt wird:
%% Cell type:code id: tags:
```
def print_lyrics():
print("Jetzt fahr'n wir über'n See, über'n See,")
print(" jetzt fahr'n wir über'n See")
```
%% Cell type:markdown id: tags:
- Dabei ist `def` ein Schlüsselwort, welches dem Python-Interpreter verrät, dass jetzt eine Funktionsdefinition folgt,
- `print_lyrics` ist der Name der Funktion (es gelten die gleichen Regeln wie für Variablennamen: nur Buchstaben, Zahlen und Unterstrich und keine Zahlen am Anfang des Namens),
- Die leeren Klammern am Ende zeigen an, dass diese Funktion keine Argumente erwartet.
- Die erste Zeile einer Funktion ist der **Kopf** (Englisch: *header*), welcher mit einem Doppelpunkt abgeschlossen wird.
- Danach kommt der **Rumpf** (Englisch: *body*), der um vier Leerzeichen eingerückt werden muss.
- Im Rumpf können beliebig viele Anweisungen stehen ... die erste Anweisung, die nicht mehr eingerückt ist, gehört nicht mehr zur Funktion.
Wenn wir das alles beachtet und richtig gemacht haben, dann können wir die Funktion aufrufen:
%% Cell type:code id: tags:
```
print_lyrics()
```
%% Cell type:markdown id: tags:
Dazu müssen wir nur den Namen der Funktion schreiben, gefolgt von den beiden Klammern.
Exkurs: Übrigens wird durch die Definition einer Funktion ein sogenanntes **Funktionsobjekt** erzeugt, dessen Typ wir uns anschauen können:
%% Cell type:code id: tags:
```
type(print_lyrics)
```
%% Cell type:markdown id: tags:
Das Objekt trägt den Namen der Funktion und ist vom Typ `function`.
Sobald wir eine Funktion definiert haben, können wir diese in anderen Funktionen verwenden. Wir könnten zum Beispiel eine Funktion `repeat_lyrics` schreiben, die unsere `print_lyrics`-Funktion zweimal aufruft. Implementieren Sie diese Funktion:
%% Cell type:code id: tags:
```
def repeat_lyrics():
```
%% Cell type:markdown id: tags:
Und rufen Sie die neu definierte Funktion jetzt auf:
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
### Definition von Funktionen und deren Aufruf
Schauen wir uns noch einmal an, was wir gerade programmiert haben:
```python
def print_lyrics():
print("Jetzt fahr'n wir über'n See, über'n See,")
print(" jetzt fahr'n wir über'n See")
def repeat_lyrics():
print_lyrics()
print_lyrics()
repeat_lyrics()
```
Dieses Programm enthält zwei Funktionsdefinitionen: `print_lyrics` und `repeat_lyrics`. Funktionsdefinitionen werden wie jede andere Anweisung auch ausgeführt, aber das Ergebnis ist, dass Funktionsobjekte erzeugt werden. Die Anweisungen innerhalb der Funktion werden dabei noch nicht ausgeführt - erst, wenn die Funktion aufgerufen wird. Die Definition einer Funktion erzeugt daher keine Ausgabe.
Vielleicht haben Sie es sich schon gedacht: Bevor wir eine Funktion nutzen können, müssen wir sie definieren. Die Funktionsdefinition muss also *vor* dem Funktionsaufruf ausgeführt werden.
Daher als Übung: verschieben Sie den Funktionsaufruf in der letzten Zeile ganz an den Anfang, so dass der Funktionsaufuruf vor den Funktionsdefinitionen erscheint und beobachten Sie, welche Fehlermeldung das ergibt:
%% Cell type:code id: tags:
```
def print_lyrics():
print("Jetzt fahr'n wir über'n See, über'n See,")
print(" jetzt fahr'n wir über'n See")
def repeat_lyrics():
print_lyrics()
print_lyrics()
repeat_lyrics()
```
%% Cell type:markdown id: tags:
Verschieben Sie den Aufruf jetzt wieder ans Ende und vertauschen Sie die Reihenfolge der beiden Funktionsdefinitionen. Was passiert dabei?
%% Cell type:markdown id: tags:
### Kontrollfluss
Damit wir sicherstellen können, dass eine Funktion definiert ist, bevor wir sie aufrufen, müssen wir die Reihenfolge kennen, in der Anweisungen ausgeführt werden - den sogenannten **Kontrollfluss**.
Die Ausführung eines Programms beginnt immer mit der ersten Anweisung. Anweisungen werden einzeln ausgeführt, von oben nach unten.
Funktionsdefinitionen verändern den Kontrollfluss eines Programms nicht (und wir erinnern uns, dass die Anweisungen innerhalb der Funktion erst ausgeführt werden, wenn die Funktion aufgerufen wird).
Ein Funktionsaufruf ist wie eine Umleitung im Kontrollfluss: Anstatt zur nächsten Anweisung zu springen, springt Python zum Rumpf der Funktion, führt die Anweisungen dort aus und springt dann zurück zum Ausgangspunkt:
Das klingt noch recht einfach ... aber wir erinnern uns: eine Funktion kann eine weitere aufrufen und diese noch eine weitere, usw. Glücklicherweise merkt sich Python immer genau, wo es ist und wohin zurückgesprungen werden muss.
Wenn wir also ein Programm zu verstehen versuchen, ist es manchmal hilfreich, das Programm nicht einfach nur von oben nach unten durchzulesen, sondern dem Kontrollfluss zu folgen, also beim Aufruf einer Funktion zu dieser Funktion zu springen und sie durchzulesen.
%% Cell type:markdown id: tags:
### Parameter und Argumente
Einige der Funktionen, die wir schon gesehen haben, benötigen **Argumente** (z.B. `print` oder `type`). Wenn wir `math.sin` aufrufen, müssen wir eine Zahl als Argument übergeben. Einige Funktionen benötigen auch mehrere Argumente (z.B. benötigt `math.pow` zwei Argumente: die Basis und den Exponenten).
Innerhalb einer Funktion werden die Argumente Variablen zugewiesen. Diese speziellen Variablen werden **Parameter** genannt. Schauen wir uns eine Funktion an, die ein Argument erwartet:
%% Cell type:code id: tags:
```
def print_twice(wert):
print(wert)
print(wert)
```
%% Cell type:markdown id: tags:
Diese Funktion weist das übergebene Argument dem Parameter `wert` zu. Wenn die Funktion aufgerufen wird, gibt Sie den Wert von `wert` zweimal mit Hilfe der `print`-Funktion aus.
Diese Funktion können wir jetzt mit beliebigen Werten aufrufen:
%% Cell type:code id: tags:
```
print_twice('Film')
print_twice(42)
```
%% Cell type:markdown id: tags:
Die Regeln zur Verknüpfung gelten auch hier: statt eines Wertes können wir auch einen Ausdruck übergeben:
%% Cell type:code id: tags:
```
print_twice('Film' * 2)
print_twice(math.cos(math.pi))
```
%% Cell type:markdown id: tags:
Das Argument wird ausgewertet (also berechnet) bevor die Funktion aufgerufen wird. Daher werden die Ausdrücke `'Film' * 2` und `math.cos(math.pi))` nur einmal ausgewertet!
Wir können auch eine Variable als Argument übergeben:
%% Cell type:code id: tags:
```
text = 'Gähn'
print_twice(text)
```
%% Cell type:markdown id: tags:
**Wichtig**: der Name der Variablen, die wir als Argument übergeben (hier: `text`) hat nichts mit dem Namen des Parameters (hier `wert`) zu tun! Egal, wie der Wert der da reinkommt ausserhalb der Funktion bezeichnet wurde -
innerhalb dieser Funktion heißt der Wert `wert`.
%% Cell type:markdown id: tags:
### Variablen und Parameter sind lokal
Wenn wir eine Variable innerhalb einer Funktion erzeugen, ist dies eine **lokale** Variable. D.h., diese Variable existiert nur innerhalb der Funktion. Zum Beispiel:
%% Cell type:code id: tags:
```
def cat_twice(part1, part2):
cat = part1 + part2
print_twice(cat)
```
%% Cell type:markdown id: tags:
Diese Funktion erwartet zwei Argumente, verkettet sie und gibt das Ergebnis zweimal aus. Testen wir das mal:
%% Cell type:code id: tags:
```
teil1 = 'Holleri du dödel di '
teil2 = 'diri diri dudel dö'
cat_twice(teil1, teil2)
```
%% Cell type:markdown id: tags:
Nachdem `cat_twice` ausgeführt wurde, wird die lokale Variable `cat` zerstört. Wenn wir versuchen darauf zuzugreifen, erhalten wir eine Fehlermeldung:
%% Cell type:code id: tags:
```
print(cat)
```
%% Cell type:markdown id: tags:
Parameter sind auch lokal. Außerhalb von `cat_twice` können wir auf `part1` nicht zugreifen:
%% Cell type:code id: tags:
```
print(part1)
```
%% Cell type:markdown id: tags:
### Stapel-Diagramme
Um den Überblick zu behalten, wo welche Variable genutzt werden kann, ist es manchmal hilfreich, ein sogenanntes **Stapel-Diagramm** (Englisch: *stack diagram*) zu zeichnen:
Das Diagramm zeigt uns den Wert jeder Variablen und auch die Funktion zu der jede Variable gehört.
Jede Funktion wird durch einen **Block** (Englisch: *frame*) repräsentiert: links neben dem Block erscheint der Name der Funktion und innerhalb des Blocks die Parameter und Variablen und die Werte, die ihnen zugewiesen wurden.
Die Blöcke sind in einem Stapel (*stack*) angeordnet, der uns zeigt, welche Funktion welche andere Funktion aufgerufen hat. In unserem Beispiel wurde `print_twice` durch `cat_twice` aufgerufen und `cat_twice` wurde durch `__main__` aufgerufen, was ein spezieller Name für den obersten Block ist. Wenn wir eine Variable ausserhalb einer Funktion erzeugen, gehört diese zu `__main__`.
Jeder Parameter verweist auf den selben Wert wie das zugehörige Argument. In unserem Fall hat also `part1` den selben Wert wie `teil1`, `part2` den selben Wert wie `teil2` und `wert` den selben Wert wie `cat`.
Wenn uns ein Fehler während eines Funktionsaufrufes unterläuft, gibt uns Python den Namen der Funktion aus, die den Fehler verursacht hat, den Namen der Funktion, die diese Funktion aufgeführt hat, usw. bis hinauf zu `__main__`.
Wenn wir z.B. versuchen, `cat` innerhalb von `print_twice` aufzurufen, bekommen wir einen `NameError`. Probieren Sie es aus:
%% Cell type:code id: tags:
```
def print_twice(wert):
print(cat)
print(wert)
print(wert)
cat_twice("eins", "zwei")
```
%% Cell type:markdown id: tags:
Diese Liste von Funktionen wird **Traceback** genannt und zeigt uns, wo der Fehler aufgetreten ist und welche Zeilen in welchen Funktionen gerade aufgerufen wurden. Die Reihenfolge ist die gleiche wie im Stapeldiagramm: die Funktion die gerade die Kontrolle hatte und ausgeführt wurde, ist ganz unten.
%% Cell type:markdown id: tags:
Reparieren wir das lieber mal wieder, damit wir die Funktion `print_twice` später noch verwenden können:
%% Cell type:code id: tags:
```
def print_twice(wert):
print(wert)
print(wert)
```
%% Cell type:markdown id: tags:
Damit lernen wir auch, dass wir eine Funktion mit dem gleichen Namen mehrmals definieren können: Jede neue Definition überschreibt einfach die vorherige und beim Aufrufen der Funktion wird die zuletzt definierte Variante ausgeführt:
%% Cell type:code id: tags:
```
print_twice("Hallo")
```
%% Cell type:markdown id: tags:
### Funktionen mit Rückgabewert
Einige der Funktionen, die wir bisher verwendet haben (z.B. die mathematischen Funktionen) geben einen Wert zurück. Andere führen eine Aktion aus, aber geben keinen Wert zurück (z.B. `print_twice`).
Wenn wir eine Funktion mit Rückgabewert aufrufen, wollen wir meistens etwas mit dem Rückgabewert anfangen, ihn z.B. einer Variable zuweisen oder innerhalb eines Ausdrucks verwenden:
%% Cell type:code id: tags:
```
x = math.cos(4)
goldener_schnitt = (math.sqrt(5) + 1)/2
```
%% Cell type:markdown id: tags:
Wenn wir eine Funktion mit Rückgabewert hier aufrufen, gibt uns Jupyter den Rückgabewert aus:
%% Cell type:code id: tags:
```
math.sqrt(5)
```
%% Cell type:markdown id: tags:
Aber wenn wir sonst nichts damit machen, dann geht der Wert verloren. Wir berechnen also etwas, aber fangen damit nichts weiter an. Daher weisen wir den Rückgabewert einer Funktion meist einer Variablen zu oder verwenden ihn in einem Ausdruck, wie oben gesehen.
Schreiben Sie einen Ausdruck auf, der die Funktion `math.sqrt` verwendet und weisen Sie das Ergebnis einer Variablen zu:
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
Funktionen ohne Rückgabewert zeigen vielleicht etwas auf dem Bildschirm an oder haben einen anderen Effekt, aber sie geben uns keinen Wert zurück. Wenn wir das Ergebnis einer solchen Funktion einer Variablen zuweisen, erhält diese den speziellen Wert `None`:
%% Cell type:code id: tags:
```
result = print_twice('Bing')
print(result)
```
%% Cell type:markdown id: tags:
Der wert `None` ist nicht das selbe wie die Zeichenkette `'None'`, sondern ein spezieller Wert mit eigenem Typ:
%% Cell type:code id: tags:
```
type(None)
```
%% Cell type:markdown id: tags:
### Eigene Funktionen mit Rückgabewert
Wir können selbst eine Funktion mit Rückgabewert schreiben, indem wir das Schlüsselwort `return` verwenden:
%% Cell type:code id: tags:
```
def area(radius):
a = math.pi * radius**2
return a
```
%% Cell type:markdown id: tags:
Diese Funktion erhält als Argument einen Wert, der dem Parameter `radius` zugewiesen wird. Innerhalb der Funktion wird dieser Wert verwendet, um eine Berechnung durchzuführen. Das Ergebnis der Berechnung wird der lokalen Variablen `a` zugewiesen, die schließlich in der letzten Zeile mittels `return a` zurückgegeben wird. Wenn wir jetzt die Funktion aufrufen, erhalten wir einen Wert zurück:
%% Cell type:code id: tags:
```
flaeche = area(3)
print(flaeche)
```
%% Cell type:markdown id: tags:
Wir werden uns Funktionen mit Rückgabewert später noch genauer anschauen.
%% Cell type:markdown id: tags:
### Exkurs: Debugging
Eine der wichtigsten Fähigkeiten, die wir gerne lernen wollen ist Debugging. Obwohl es manchmal frustrierend ist, ist es eine der intellektuell anspruchsvollsten, herausforderndsten und interessantesten Aspekte des Programmierens.
Debugging ist wie Detektiv spielen: Wir haben ein paar Hinweise und wir müssen die Vorgänge und Ereignisse herausfinden, die zu den Ergebnissen geführt haben, die wir sehen.
Debugging ist aber auch wie experimentelle Wissenschaft: Wenn wir erstmal eine Idee haben, was schiefgelaufen sein könnte, können wir unser Programm verändern und es noch einmal versuchen. Wenn unsere Annahme richtig war, können wir das Ergebnis unserer Veränderung vorhersagen und mit dem realen Ergebnis vergleichen. Damit kommen wir hoffentlich einem richtig funktionierendem Programm näher. Wenn unsere Annahme falsch war, müssen wir uns eine neue Ausdenken. Wie schon Sherlock Holmes sagte: "Wenn man das Unmögliche ausgeschlossen hat, muss das, was übrig bleibt - wie unwahrscheinlich auch immer - die Wahrheit sein" (A. Conan Doyle, *The Sign of Four*).
Für viele Menschen ist Programmieren und Debugging das gleiche. D.h., Programmieren bedeutet, dass man ein Programm solange debuggt, bis es das tut, was man möchte. Die Idee ist, dass man mit einem kleinen, einfachen Programm beginnt und solange kleine Änderungen vornimmt und debuggt, bis es tut was es soll.
Zum Beispiel ist Linux ein Betriebssystem, was auf Millionen von Rechnern verwendet wird und Millionen von Codezeilen enthält, aber es begann als ein einfaches Programm welches der finnische Student Linus Torvalds geschrieben hat, um den Intel 386 Prozessor besser zu verstehen. Laut Larry Greenfield war einer der ersten Versuche von Linus ein Programm, welches abwechselnd "AAAA" und "BBBB" ausgab. Daraus wurde später Linux. (*The Linux Users’ Guide Beta Version 1*).
%% Cell type:markdown id: tags:
### Glossar
Legen wir uns eine Liste mit den wichtigsten Begriffen an, die wir im Kapitel 3 gelernt haben:
- Funktion:
- Funktionsdefinition:
- Funktionsobjekt:
- Kopf:
- Rumpf:
- Parameter:
- Funktionsaufruf:
- Argument:
- lokale Variable:
- Rückgabewert:
- `None`:
- Modul:
- `import`-Anweisung:
- Modul-Objekt:
- Punkt-Schreibweise:
- Verknüpfung:
- Kontrollfluss:
- Stapel-Diagramm:
- Box:
- Traceback:
Ergänzen Sie die Liste in eigenen Worten. Das ist eine gute Erinnerungs- und Übungsmöglichkeit.
%% Cell type:markdown id: tags:
### Übung
### Aufgabe 1
Diese Aufgabe kennen Sie schon vom Seminar letzte Woche. Sie haben drei Möglichkeiten:
1. Überspringen Sie die Aufgabe, weil Sie verstanden haben, wie alles funktioniert.
2. Lösen Sie die Aufgabe selbständig.
3. Scrollen Sie etwas herunter und lösen Sie die Aufgabe mit etwas Hilfe ("Lückentext").
Schreiben Sie eine Funktion `right_justify` die eine Zeichenkette als Parameter `s` erwartet und diese Zeichenkette rechtsbündig ausgibt, d.h., die Zeichenkette und so viele Leerzeichen davor ausgibt, dass der letzte Buchstabe der Zeichenkette in Spalte 70 angezeigt wird.
Beispiel: wenn wir die fertige Funktion mit dem Wert `monty` aufrufen, soll folgendes passieren:
```python
right_justify('monty')
monty
```
Tipp: Nutzen Sie die Zeichenkettenverknüpfung und -wiederholung. Python bietet uns auch eine Funktion an, mit der wir die Länge einer Zeichenkette ermitteln können. Diese Funktion heißt `len`. Sie erwartet als Argument eine Zeichenkette und gibt ihre Länge zurück. Der Rückgabewert von `len('monty')` ist also `5`.
%% Cell type:code id: tags:
```
# Definieren Sie hier die Funktion right_justify:
```
%% Cell type:code id: tags:
```
# Wenn Sie fertig sind, rufen Sie die Funktion hier auf:
right_justify("Monty Python's")
right_justify('The Ministry of Silly Walks')
# (und testen Sie die Funktion zwischendurch immer mal)
Bitte hier nur weiterlesen, wenn Sie Hilfe benötigen. Versuchen Sie es aber vorher unbedingt erst einmal zu zweit. Das Erfolgserlebnis, die Lösung selber gefunden zu haben, lohnt die Mühe. Und nur so lernen Sie etwas dazu.
.
.
.
spoiler
.
.
So sollte der Kopf Ihrer Funktion ausehen (alle notwendigen Informationen dazu stehen im ersten Teil des ersten Satzes der Aufgabe):
```python
def right_justify(s):
```
.
.
Jetzt ein paar Tipps, wie Sie das Problem angehen könnten. Lesen Sie nicht alles auf einmal durch, sondern nur jeweils einen Tipp und versuchen Sie dann erstmal wieder, das Problem zu zweit zu lösen:
1. Wieviele Leerzeichen benötigen Sie, um 'monty' rechtsbündig auszugeben? (Falls Sie die Frage nicht beantworten können, lesen Sie sich die Aufgabe nochmal genau durch.)
2. Wie können Sie diese Anzahl berechnen? Welche Werte benötigen Sie dafür?
3. Das alles können Sie jetzt schon in Ihre Funktion packen.
4. Funktioniert das was Sie geschrieben haben auch für andere Werte als 'monty', insbesondere für den Parameter `s` der Funktion?
5. Wenn Sie jetzt ausgerechnet haben, wie viele Leerzeichen Sie benötigen, müssen Sie diese noch erzeugen.
6. Dafür können Sie den Operator `*` für Zeichenkettenwiederholung verwenden.
7. `' ' * 10` ergibt z.B. 10 Leerzeichen
8. Jetzt haben Sie genug Leerzeichen ... aber die müssen ja noch vor die Zeichenkette `s`.
9. Sie können Zeichenketten mittels `+` verknüpfen.
10. `' ' * 65 + 'monty'` wäre die Zeichenkette, die Sie für 'monty' bräuchten ... aber wie können Sie das allgemein formulieren, so dass es auch für den Parameter `s` (mit beliebiger Länge!) funktioniert?
11. Schließlich müssen Sie das Ergebnis noch ausgeben ... nungut, dafür gibt's die `print`-Funktion.
12. Alles geschafft? Geben Sie hier ihre fertige Funktion ein:
%% Cell type:code id: tags:
```
def right_justify(s):
# Anzahl Leerzeichen berechnen
anzahl_leerzeichen =
# Zeichenkette erzeugen
ergebnis =
# und ausgeben
print()
```
%% Cell type:markdown id: tags:
Macht ihre Funktion auch wirklich, was sie soll? Ein paar Ideen zum Testen:
- Zählen Sie die Leerzeichen bis zum Wort. Das ist schwierig, da Leerzeichen schwer zu sehen sind. Also tauschen Sie doch das Leerzeichen durch ein anderes Zeichen, z.B. einen Punkt aus.
- Jetzt sind es bei kurzen Wörtern recht viele Punkte ... als Abhilfe könnten Sie statt in der 70. Spalte alles rechtsbündig in der 10. Spalte ausgeben, also 70 zu 10 ändern. Dann lässt es sich leichter zählen.
Wenn Ihre Funktion so richtig funktioniert, dann sollte sie auch mit Leerzeichen und Spalte 70 korrekt funktionieren. Das ist auch Debugging und Testen - es ist wichtig, um Fehler zu finden und hilft Ihnen, mit Ihrem Programm vertrauter zu werden.
Abschlussfrage: was passiert, wenn Sie die Funktion mit einer Zeichenkette aufrufen, die länger als 70 Zeichen ist? Probieren Sie es aus:
%% Cell type:code id: tags:
```
right_justify('Abschlussfrage: was passiert, wenn Sie die Funktion mit einer Zeichenkette aufrufen, die länger als 70 Zeichen ist?')
```
%% Cell type:markdown id: tags:
#### Aufgabe 1+
Testen Sie folgendermaßen, ob Sie verstanden haben, wie die Funktion `right_justify` funktioniert: Schreiben Sie eine Funktion `center`, die eine als Argument übergebene Zeichenkette zentriert ausgibt (bei einer angenommen maximalen Spaltenbreite von 70, wie gerade eben):
%% Cell type:code id: tags:
```
```
%% Cell type:markdown id: tags:
Tipp zur Lösung: Mit dem Operator `//` können wir zwei ganze Zahlen so teilen, dass eine ganze Zahl (*integer*) herauskommt. Während `7 / 2` die Fließkommazahl `3.5` ergibt, erhalten wir bei `7 // 2` die ganze Zahl `3` (es wird stets abgerundet).
Ein Aufruf der Funktion mit den folgenden Argumenten:
%% Cell type:code id: tags:
```
center('Diese Wörter')
center('stehen')
center('in')
center('der Mitte')
```
%% Cell type:markdown id: tags:
sollte folgendes Ergebnis liefern:
```
Diese Wörter
stehen
in
der Mitte
```
%% Cell type:markdown id: tags:
#### Aufgabe 2
Ein Funktionsobjekt ist ein Wert, den wir einer Variablen zuweisen können oder auch einer Funktion als Argument übergeben können. Zum Beispiel ist `do_twice` eine Funktion, die ein Funktionsobjekt als Argument erwartet und die Funktion dann zweimal aufruft:
%% Cell type:code id: tags:
```
def do_twice(f):
f()
f()
```
%% Cell type:markdown id: tags:
Im Folgenden ein Beispiel, in dem die Funktion `do_twice` genutzt wird, um die Funktion `print_spam` zweimal aufzurufen:
```python
def print_spam():
print('spam')
do_twice(print_spam)
```
%% Cell type:markdown id: tags:
(Tipp: Mit der Tastenkombination `SHIFT STRG -` können wir einen Block teilen - also `SHIFT` und `STRG` gleichzeitig gedrückt halten und dann die Minustaste drücken. So können Sie Ihren Code direkt hinter jeder der folgenden Teilaufgaben einfügen.)
%% Cell type:markdown id: tags:
1. Geben Sie dieses Beispiel in einen Code-Block ein und testen Sie es.
2. Ändern Sie `do_twice`, so dass
- es zwei Argumente erwartet: ein Funktionsobjekt und einen Wert und
- die übergebene Funktion zweimal aufruft und ihr den Wert als Argument übergibt.
3. Rufen Sie mit der geänderten Funktion `do_twice` die Funktion `print_twice` (die wir weiter vorne definiert hatten) auf und übergeben Sie ein Wort Ihrer Wahl als Argument.
4. Definieren Sie eine Funktion `do_four`, die ein Funktionsobjekt und einen Wert erwartet und die übergebene Funktion viermal aufruft und ihr dabei den Wert als Parameter übergibt. Die Funktion `do_four` sollte dabei aus nur zwei Zeilen im Rumpf bestehen, nicht aus vier!
.
.
Die Lösung finden Sie hier: http://thinkpython2.com/code/do_four.py
%% Cell type:markdown id: tags:
#### Aufgabe 3
Lösen Sie die folgende Aufgabe: http://greenteapress.com/thinkpython2/html/thinkpython2004.html#hevea_default261
%% Cell type:markdown id: tags:
#### Bonusaufgabe
Erinnern Sie sich noch an die folgende Aufgabe?
1. Finden Sie einen Algorithmus zur Lösung des folgenden Problems:
*Gegeben sei eine positive ganze Zahl `n`. Finden Sie eine Liste
von positiven ganzen Zahlen, so dass das Produkt der Zahlen am
größten unter allen positiven ganzen Zahlen ist, deren Summe
gleich `n` ist.*
Zum Beispiel:
- Für `n = 4` ist die gesuchte Liste `(2,2)`, denn `2 * 2` ist größer als `1 * 1 * 1 * 1`, `2 * 1 * 1` und `3 * 1`.
- Für `n = 5` ist die gesuchte Liste `(2,3)`.
2. Wie lautet die Liste für `n = 2001`?
3. Erklären Sie, wie Sie "einen Fuß in die Tür bekommen" haben.
Versuchen Sie es zunächst ohne Hilfe. Wie kann Ihnen Python dabei helfen?
.
.
.
Mein "Fuß in der Tür" war, dass ich von Hand eine Tabelle mit den Ergebnissen für die ersten `n` Zahlen gebaut habe:
| n | Liste | Produkt |
|----|-----------|---------|
| 2 | 1 1 | 1 |
| 3 | 1 2 | 3 |
| 4 | 2 2 | 4 |
| 5 | 2 3 | 6 |
%% Cell type:markdown id: tags:
Ergänzen Sie diese Tabelle von Hand. Dabei kann Ihnen eine Funktion helfen, die für eine gegebene Liste an Zahlen das Produkt und die Summe berechnet:
%% Cell type:code id: tags:
```
def prodsum(zahlen):
prod = 1
summ = 0
for zahl in zahlen:
prod = prod * zahl
summ = summ + zahl
print("Produkt =", prod, "Summe =", summ)
```
%% Cell type:markdown id: tags:
Eine Liste von Zahlen können wir mit erzeugen, indem wir die Zahlen durch Komma getrennt zwischen zwei Klammern schreiben:
%% Cell type:code id: tags:
```
(2,3)
```
%% Cell type:markdown id: tags:
Wir können also `prodsum` so aufrufen:
%% Cell type:code id: tags:
```
prodsum((2,3))
```
%% Cell type:markdown id: tags:
Testen Sie für jedes `n` mehrere Listen, bis Sie sich jeweils sicher sind, die mit dem größten Produkt gefunden zu haben.
.
.
.
Ich habe mit Hilfe der Funktion die Tabelle bis `n=15` ergänzt bis ich mir sicher war, dass ich das Prinzip verstanden hatte.
.
.
.
Sehen Sie jetzt ein Muster in der Tabelle? Die Produkte bestehen nur aus 3en und ggf. noch 2en oder 4en. Genauer:
Beobachtung ("Fuß in der Tür"):
- Ein Produkt aus möglichst vielen Dreien ergibt das beste Ergebnis.
- Falls es nicht ganz aufgeht, mit 2 oder 4 auffüllen.
Erklärung (warum Dreien?):
- Ob wir eine Vier oder zwei Zweien nehmen, ist egal, da `2+2 = 4 = 2*2`.
- Da `2+3=5` aber `2*3=6`, lohnt es sich nicht, größere Zahlen zu nehmen
(ebenso: `3+3=6` aber `3*3=9`) - das Produkt der kleinen Zahlen ist stets größer als ihre Summe
Algorithmus:
%% Cell type:code id: tags:
```
def produkt_summe(n):
"""Berechnet für gegebenes n>2 das Produkt derjenigen Liste von
Zahlen, deren Summe n ergibt und gleichzeitig die größte Liste mit
dieser Eigenschaft ist.
Vorgehen: wiederholt 3 von n abziehen, bis der Rest kleiner oder
gleich 4 ist. (letzter Schritt klappt, weil 2+2=4=2*2)
"""
rest = n
prod = 1
zahlen = []
while rest > 4:
rest = rest - 3
prod = prod * 3
zahlen.append(3)
prod = prod * rest
zahlen.append(rest)
print("*".join([str(z) for z in zahlen]), "=", prod)
print("+".join([str(z) for z in zahlen]), "=", sum(zahlen))
```
%% Cell type:markdown id: tags:
Testen wir es einmal aus:
%% Cell type:code id: tags:
```
produkt_summe(14)
```
%% Cell type:markdown id: tags:
Das sollte auch die Zahl sein, die Sie für `n=14` oben in Ihrer Tabelle stehen haben.
Die Funktion verwendet zwar ein paar Dinge, um eine schöne Ausgabe zu erzeugen, aber die wesentliche Funktionalität in der `while`-Schleife zur Berechnung des Produkts besteht nur aus Konstrukten, die wir schon kennengelernt haben.
([PythoRandall Munroe
([Python](https://xkcd.com/353/), Randall Munroe)
%% Cell type:markdown id: tags:
 Speichern Sie dieses Notebook, so dass Ihre Änderungen nicht verlorengehen (nicht auf einem Pool-Rechner). Rufen Sie dazu im Menü "File" den Punkt "Download as"->"Notebook" auf und nutzen Sie beispielsweise einen USB-Stick, E-Mail, Google Drive, Dropbox oder Ihre [HU-Box](https://box.hu-berlin.de/).
