"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:"
"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. Wie Sie sehen, erscheint die Ausgabe `\"Der Typ des Ausdrucks 27 + 3 ist: <class 'int'>\"`. Haben Sie das so erwartet? Versuchen Sie, die einzelnen Schritte im Ausdruck `str(type(27+3))` nachzuvollziehen. Ggf. mit [PytonTutor](https://pythontutor.com/render.html#mode=edit).\n"
**Funktionen** bezeichnen eine benannte Folge von Anweisungen. Wenn wir eine Funktion definieren, dann geben wir der Funktion einen Namen und fügen die Folge von Anweisungen, die die Funktion ausführen sollen, hinzu. Später können wir die Funktion mit ihrem Namen **aufrufen**.
**Bevor Sie mit diesem Notebook starten, sollten Sie wiederholen, was Sie im letzten Notebook gelernt haben. Gehen Sie zurück und schauen Sie sich mindestens das Glossar an und wiederholen Sie die dort genannten Begriffe.**
%% Cell type:markdown id: tags:
<h1>Inhalt<spanclass="tocSkip"></span></h1>
<divclass="toc"><ulclass="toc-item"><li><span><ahref="#Ihre-Lernziele"data-toc-modified-id="Ihre-Lernziele-1"><spanclass="toc-item-num">1 </span>Ihre Lernziele</a></span></li><li><span><ahref="#Exkurs:-Was-mir-an-Python-gefällt"data-toc-modified-id="Exkurs:-Was-mir-an-Python-gefällt-2"><spanclass="toc-item-num">2 </span>Exkurs: Was mir an Python gefällt</a></span></li><li><span><ahref="#Warum?"data-toc-modified-id="Warum?-3"><spanclass="toc-item-num">3 </span>Warum?</a></span></li><li><span><ahref="#Funktionsaufrufe"data-toc-modified-id="Funktionsaufrufe-4"><spanclass="toc-item-num">4 </span>Funktionsaufrufe</a></span></li><li><span><ahref="#Mathematische-Funktionen"data-toc-modified-id="Mathematische-Funktionen-5"><spanclass="toc-item-num">5 </span>Mathematische Funktionen</a></span></li><li><span><ahref="#Verknüpfung"data-toc-modified-id="Verknüpfung-6"><spanclass="toc-item-num">6 </span>Verknüpfung</a></span></li><li><span><ahref="#Neue-Funktionen-hinzufügen"data-toc-modified-id="Neue-Funktionen-hinzufügen-7"><spanclass="toc-item-num">7 </span>Neue Funktionen hinzufügen</a></span></li><li><span><ahref="#Definition-von-Funktionen-und-deren-Aufruf"data-toc-modified-id="Definition-von-Funktionen-und-deren-Aufruf-8"><spanclass="toc-item-num">8 </span>Definition von Funktionen und deren Aufruf</a></span></li><li><span><ahref="#Kontrollfluss"data-toc-modified-id="Kontrollfluss-9"><spanclass="toc-item-num">9 </span>Kontrollfluss</a></span></li><li><span><ahref="#Parameter-und-Argumente"data-toc-modified-id="Parameter-und-Argumente-10"><spanclass="toc-item-num">10 </span>Parameter und Argumente</a></span></li><li><span><ahref="#Variablen-und-Parameter-sind-lokal"data-toc-modified-id="Variablen-und-Parameter-sind-lokal-11"><spanclass="toc-item-num">11 </span>Variablen und Parameter sind lokal</a></span></li><li><span><ahref="#Stapel-Diagramme"data-toc-modified-id="Stapel-Diagramme-12"><spanclass="toc-item-num">12 </span>Stapel-Diagramme</a></span></li><li><span><ahref="#Funktionen-mit-Rückgabewert"data-toc-modified-id="Funktionen-mit-Rückgabewert-13"><spanclass="toc-item-num">13 </span>Funktionen mit Rückgabewert</a></span></li><li><span><ahref="#Exkurs:-Eigene-Funktionen-mit-Rückgabewert"data-toc-modified-id="Exkurs:-Eigene-Funktionen-mit-Rückgabewert-14"><spanclass="toc-item-num">14 </span>Exkurs: Eigene Funktionen mit Rückgabewert</a></span></li><li><span><ahref="#Debugging"data-toc-modified-id="Debugging-15"><spanclass="toc-item-num">15 </span>Debugging</a></span></li><li><span><ahref="#Glossar"data-toc-modified-id="Glossar-16"><spanclass="toc-item-num">16 </span>Glossar</a></span></li><li><span><ahref="#Übung"data-toc-modified-id="Übung-17"><spanclass="toc-item-num">17 </span>Übung</a></span><ulclass="toc-item"><li><span><ahref="#Aufgabe-1"data-toc-modified-id="Aufgabe-1-17.1"><spanclass="toc-item-num">17.1 </span>Aufgabe 1</a></span><ulclass="toc-item"><li><span><ahref="#Aufgabe-1a"data-toc-modified-id="Aufgabe-1a-17.1.1"><spanclass="toc-item-num">17.1.1 </span>Aufgabe 1a</a></span><ulclass="toc-item"><li><span><ahref="#Lückentext"data-toc-modified-id="Lückentext-17.1.1.1"><spanclass="toc-item-num">17.1.1.1 </span>Lückentext</a></span></li></ul></li><li><span><ahref="#Aufgabe-1b"data-toc-modified-id="Aufgabe-1b-17.1.2"><spanclass="toc-item-num">17.1.2 </span>Aufgabe 1b</a></span></li></ul></li><li><span><ahref="#Aufgabe-2"data-toc-modified-id="Aufgabe-2-17.2"><spanclass="toc-item-num">17.2 </span>Aufgabe 2</a></span></li><li><span><ahref="#Aufgabe-3"data-toc-modified-id="Aufgabe-3-17.3"><spanclass="toc-item-num">17.3 </span>Aufgabe 3</a></span><ulclass="toc-item"><li><span><ahref="#Aufgabe-3.1"data-toc-modified-id="Aufgabe-3.1-17.3.1"><spanclass="toc-item-num">17.3.1 </span>Aufgabe 3.1</a></span></li><li><span><ahref="#Aufgabe-3.2"data-toc-modified-id="Aufgabe-3.2-17.3.2"><spanclass="toc-item-num">17.3.2 </span>Aufgabe 3.2</a></span></li></ul></li><li><span><ahref="#Bonusaufgabe"data-toc-modified-id="Bonusaufgabe-17.4"><spanclass="toc-item-num">17.4 </span>Bonusaufgabe</a></span></li></ul></li></ul></div>
%% Cell type:markdown id: tags:
## Ihre Lernziele
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
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 plt
# 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]
plt.plot(x, sinx, label='sin(x)')
plt.plot(x, cosx, label='cos(x)')
plt.grid(linestyle="dashed")
plt.legend()
plt.show()
```
%% Cell type:markdown id: tags:
## Warum?
Warum ist es sinnvoll, ein Programm in Funktionen aufzuteilen?
Hier einige Beispiele:
-**Lesbarkeit** - Mit einer Funktion können wir eine Gruppe von Anweisungen benennen und so beschreiben was die Gruppe macht.
-**Fehlersuche** - Lange Programme in Funktionen aufzuteilen ermöglicht es, das Programm funktionsweise zu debuggen und später zusammen zu setzen.
-**Testbarkeit** - Analog zur Fehlersuche kann jede Funktion einzeln getestet werden.
-**kürzerer Programmcode** - Durch Funktionen können Wiederholungen im Quellcode reduziert oder eliminiert werden.
-**Wartbarkeit** - Dadurch, dass sich Quellcode nicht (bzw. kaum) wiederholt, können Änderungen an nur einer Stelle vorgenommen werden und die Effekte sind im gesamten Programm zu sehen.
-**Wiederverwendbarkeit** - Eine gut funktionierende Funktion kann in vielen Programmen sinnvoll verwendet werden.
%% 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 Gleitkommazahlen in ganze Zahlen umwandeln. Allerdings wird dabei der Teil hinter dem Dezimalpunkt abgeschnitten und nicht gerundet:
%% Cell type:code id: tags:
```
int(32.7)
```
%% Cell type:markdown id: tags:
Analog dazu können wir mit der `float`-Funktion ganze Zahlen und Zeichenketten in Gleitkommazahlen 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:
Anfangs hatten Sie Gänsefüßchen als "Markierung" für Zeichenketten kennengelernt. In Python ist es auch möglich Zeichenketten mit 'einfachen Hochkommata' einzuschließen. Das ermöglicht uns z.B. Sätze mit wörtlicher Rede darzustellen, so zum Beispiel den Satz: 'Da sagte er: "Heute wird es regnen" und ging ab.'; umgekehrt können wir mit 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:
**Tipp**: Nutzen Sie [Pythontutor](http://pythontutor.com), um Ihren Code nachvollziehen zu können und Fehler zu finden!
%% 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.
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 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 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:
```
import math
# ohne Verknüpfung
degrees = 120
radiant = degrees / 360.0 * 2 * math.pi
x = math.sin(radiant)
print(x)
```
%% Cell type:code id: tags:
```
import math
# mit Verknüpfung
degrees = 120
x = math.sin(degrees / 360.0 * 2 * math.pi)
print(x)
```
%% Cell type:markdown id: tags:
und sogar Funktionsaufrufe:
%% Cell type:code id: tags:
```
import math
# ohne Verknüpfung
x_1 = 2 + math.pi
x_2 = math.log(x_1)
x = math.exp(x_2)
print(x)
```
%% Cell type:code id: tags:
```
import math
# mit Verknüpfung
x = math.exp(math.log(2 + math.pi))
print(x)
```
%% 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:
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. Wie Sie sehen, erscheint die Ausgabe `"Der Typ des Ausdrucks 27 + 3 ist: <class 'int'>"`. Haben Sie das so erwartet? Versuchen Sie, die einzelnen Schritte im Ausdruck `str(type(27+3))` nachzuvollziehen. Ggf. mit [PytonTutor](https://pythontutor.com/render.html#mode=edit).
%% 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 mehr.)
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 beschreibt die Folge von Anweisungen, die ausgeführt werden, wenn die Funktion aufgerufen 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, nicht mehr eingerückte, Anweisung 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 - analog zum Aufruf von vordefinierten Funktionen - den Namen der Funktion **gefolgt von den Klammern** schreiben. Die Klammern sind leer, da die Funktion keine Argumente erwartet.
Ü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 Sie 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:
***Achtung:** Falls Sie keine Fehlermeldung erhalten, müssen Sie den Jupyter-Kernel neustarten, da sich Jupyter die ursprüngliche Funktionsdefinition gemerkt hat. Wählen Sie dafür "Restart & Clear Output" im "Kernel"-Menü.*
Verschieben Sie den Aufruf jetzt wieder ans Ende und vertauschen Sie die Reihenfolge der beiden Funktionsdefinitionen. Was passiert dabei?
Visualisieren Sie das Ausführen der Funktionen mit [PythonTutor](https://pythontutor.com/render.html#mode=edit). Dies veranschaulicht Ihnen den Kontrollfluss.
%% 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 und der Reihe nach ausgeführt; von oben nach unten.
Funktionsdefinitionen verändern den Kontrollfluss eines Programms nicht — Anweisungen innerhalb der Funktion werden zunächst übersprungen und erst ausgeführt, wenn die Funktion aufgerufen wird.
Ein Funktionsaufruf ist wie eine Umleitung im Kontrollfluss: Anstatt zur nächsten Anweisung zu gehen, springt Python zum Rumpf der Funktion, führt die Anweisungen dort aus und springt dann zurück zum Ausgangspunkt:
(Quelle: Brookshear & Brylow, 2015: Computer Science: An Introduction)
Es ist also so, als ob bei dem Aufruf von `repeat_lyrics` eigentlich folgender Code gelesen wird:
%% Cell type:code id: tags:
```
repeat_lyrics()
print_lyrics()
print("Jetzt fahr'n wir über'n See, über'n See,")
print(" jetzt fahr'n wir über'n See")
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:
Das klingt noch recht einfach aber erinnern Sie sich? Jede Funktion kann eine weitere aufrufen, sodass diese Abweichung im Kontrollfluss mehrere Funktionen tief gehen kann. Glücklicherweise merkt sich Python immer genau, wo es ist und wohin zurückgesprungen werden muss.
Zusammengefasst heißt das: Um ein Programm zu verstehen, ist es hilfreich das Programm nicht einfach von oben nach unten durchzulesen. Stattdessen sollte man dem Kontrollfluss folgen, also immer zu der aufgerufenen Funktion springen und diese durchlesen.
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; anstelle eines Wertes können wir 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, den wir übergeben, außerhalb der Funktion benannt 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; das heißt 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, 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 und zugehöriges Argument verweisen auf den selben Wert. 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 während eines Funktionsaufrufes ein Fehler unterläuft, gibt uns Python den Namen der Funktion aus, die den Fehler verursacht hat, den Namen der Funktion, die diese Funktion ausgefü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 — wie bei Variablen — 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:
Einige der Funktionen, die wir bisher verwendet haben (z.B. die mathematischen Funktionen) geben einen Wert zurück. Andere führen eine Aktion aus, geben aber keinen Wert zurück (z.B. `print_twice`). Diese werden auch **void functions** — also leere Funktionen genannt.
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:
```
import math
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:
```
import math
math.sqrt(5)
```
%% Cell type:markdown id: tags:
Aber wenn wir sonst nichts damit machen, geht der Wert verloren. Wir berechnen also etwas und 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:
Leere Funktionen 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 keine Zeichenkette, sondern ein spezieller Wert mit eigenem Typ:
%% Cell type:code id: tags:
```
type(None)
```
%% Cell type:markdown id: tags:
## Exkurs: Eigene Funktionen mit Rückgabewert
Dieser Abschnitt taucht nicht im englischen Python-Kurs auf und gibt einen Ausblick auf ein späteres Kapitel. Wir können selbst eine Funktion mit Rückgabewert schreiben, indem wir das Schlüsselwort `return` verwenden:
%% Cell type:code id: tags:
```
import math
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:
Schreiben Sie die Funktion `area_triangle` die den Flächeninhalt eines Dreieckes berechnet und zurückgibt. Das Dreieck sei durch die Längen `a, b` und `c` seiner drei Seiten gegeben. Verwenden Sie dazu den [Satz des Heron](https://de.wikipedia.org/wiki/Satz_des_Heron), wonach der Flächeninhalt gleich
Sie können die Quadratwurzel einer Zahl mit der Funktion `math.sqrt` berechnen. Stellen Sie sicher, dass Sie das `math`- Modul importiert haben. Führen Sie die entsprechende Zeile im Zweifelsfall erneut aus.
</div>
</details>
Versuchen Sie, die Aufgabe zunächst selber zu lösen. Wenn nötig, nutzen Sie die folgenden Hinweise:
In der Aufgabenstellung oben werden zwei Formeln gegeben. Wie stehen Sie miteinander in Verbindung? Übersetzen Sie beide Formeln in Python-Code und schreiben Sie sie innerhalb der Funktionsdefinition auf.
Die beiden Formeln sind: `s = (a + b + c) / 2` und `area = math.sqrt(s * (s - a) * (s - b) * (s - c))`.
</div>
</details>
%% Cell type:code id: tags:
```
import math
def area_triangle(a, b, c):
# Formulieren Sie hier den Rumpf der Funktion
```
%% Cell type:markdown id: tags:
Testen Sie Ihr Ergebnis mit einem Dreieck mit den Seitenlängen 3, 4 und 5. Der Flächeninhalt sollte 6 ergeben:
%% Cell type:code id: tags:
```
print(area_triangle(3, 4, 5))
```
%% Cell type:markdown id: tags:
Wir werden uns Funktionen mit Rückgabewert später noch genauer anschauen.
%% Cell type:markdown id: tags:
## Debugging
Eine der wichtigsten Fähigkeiten des Programmierens ist **Debugging**. Obwohl es manchmal frustrierend ist, ist es einer 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 eine **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. Damit kommen wir hoffentlich einem richtig funktionierendem Programm näher. Wenn unsere Annahme falsch war, müssen wir uns eine neue überlegen. 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 einige Menschen ist Programmieren und Debugging das gleiche. Das heißt, 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 - und vor allem funktionierenden- Programm beginnt und solange kleine Änderungen vornimmt bis es tut was es soll. Währenddessen muss man natürlich konstant debuggen.
Ein Beispiel ist **Linux**: ein Betriebssystem, welches auf Millionen von Rechnern verwendet wird und Millionen von Codezeilen enthält. Linux 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: Der Kopf einer Funktionsdefinition gibt den Namen der Funktion sowie alle geforderten Argumente in Klammern an und wird von einem Doppelpunkt abgeschlossen.
- 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
#### Aufgabe 1a
Diese Aufgabe ist etwas schwieriger, daher haben Sie zwei Möglichkeiten:
1. Lösen Sie die Aufgabe selbständig.
2. 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. Konkret heißt das, dass so viele Leerzeichen vor der Zeichenkette ausgibt, dass der letzte Buchstabe der Zeichenkette in Spalte 70 angezeigt wird. Es kann sein, dass Spalte 70 in Ihrer Ausgabe nicht ganz rechtsbündig ist. Das ist aber nicht schlimm, 70 kann trotzdem verwendet werden. Das folgende Beispiel zeigt einen "rechtsbündigen" Aufruf.
Beispiel: wenn wir die fertige Funktion mit dem Wert `monty` aufrufen, soll folgendes passieren:
```python
right_justify('monty')
monty
```
Zunächst ein allgemeiner Hinweis, der Elemente von Python aufzeigt, die für die Lösung des Problems wichtig sind: 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`.
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. Wenn Sie mit diesen Tipps nicht weiterkommen, finden Sie ein wenig weiter Unten einen Lückentext, den Sie vervollständigen sollen. Die Beste Übung für Sie ist es diese Aufgabe mit so wenigen Hinweisen wie möglich zu lösen.
Lösen Sie die Aufgabe zunächst für die Zeichenkette 'monty' und verallgemeinern Sie diese Lösung anschließend.
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.)
Geben Sie das Wort 'monty' rechtsbündig aus, verwenden Sie dabei nicht die konkret berechneten Zahlen, sondern die Berechnungen, die Sie durchgeführt haben.
Wenn Sie unsicher sind, wie Sie mehrere Elemente in einer 'print' Anweisung ausgeben können, schauen Sie sich noch einmal das 'print'- Tutorium aus dem 2. Notebook an.
Mit dem '*' Operator können Sie ein Leerzeichen beliebig oft ausgeben, nutzen Sie dies, um die korrekte Anzahl an Leerzeichen zu drucken, `' ' * 10` ergibt z.B. 10 Leerzeichen.
`' ' * 65 + 'monty'` wäre die Zeichenkette, die Sie für 'monty' bräuchten. Wie können Sie das allgemein formulieren, sodass es auch für den Parameter `s` (mit beliebiger Länge) funktioniert?
Ersetzen Sie 'monty' durch den Buchstaben s. (Dies müsste an 2 Stellen notwendig sein, einmal in der Berechnung der Leerzeichen und einmal in der print- Anweisung.)
</div>
</details>
%% Cell type:code id: tags:
```
# Definieren Sie hier die Funktion right_justify:
# (und testen Sie die Funktion zwischendurch immer mal)
```
%% Cell type:code id: tags:
```
# Wenn Sie fertig sind, rufen Sie die Funktion hier auf:
print(right_justify("Monty Python's"))
print(right_justify('The Ministry of Silly Walks'))
# (und testen Sie die Funktion zwischendurch immer mal)
```
%% 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. Zum Zählen können Sie das Leerzeichen durch ein anderes Zeichen — zum Beispiel einen Punkt — ersetzen.
- Bei kurzen Wörtern sind es recht viele Punkte; als Abhilfe könnten Sie, statt in der 70. Spalte, alles rechtsbündig in der 10. Spalte ausgeben, also 70 Zeichen auf 10 reduzieren. Dann lässt es sich leichter zählen.
Wenn Ihre Funktion so richtig funktioniert, sollte sie auch mit Leerzeichen statt Punkten und rechtsbündig in Spalte 70 statt Spalte 10 korrekt funktionieren. Das ist auch Debugging und Testen — es ist wichtig, um Fehler zu finden und hilft Ihnen, mit Ihrem Programm vertrauter zu werden.
%% Cell type:markdown id: tags:
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?')
Bitte hier nur weiterlesen, wenn Sie weitere Hilfe benötigen. Versuchen Sie es aber vorher unbedingt erst einmal zu zweit. Es lohnt sich die Lösung selber herauszufinden; so lernen Sie am meisten dazu.
.
.
.
So sollte der Kopf Ihrer Funktion ausehen (alle notwendigen Informationen dazu stehen im ersten Teil des ersten Satzes der Aufgabe):
Wenn Sie Ihren Lösungsweg mit einer möglichen Lösung vergleichen wollen können Sie diese hier finden. Allerdings gibt es häufig mehr als einen Lösungsweg, wenn Ihre Lösung anders aussieht ist dies nicht zwingend falsch. Wenn Sie sich unsicher sind, fragen Sie bitte nach:
%% Cell type:code id: tags:
```
def right_justify(s):
# Anzahl Leerzeichen berechnen
anzahl_leerzeichen = 70 - len(s)
# Zeichenkette erzeugen
ergebnis = " " * anzahl_leerzeichen + s
# und ausgeben
print(ergebnis)
```
%% Cell type:markdown id: tags:
#### Aufgabe 1b
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):
Mit dem Operator `//` können wir zwei ganze Zahlen so teilen, dass eine ganze Zahl (*integer*) herauskommt. Während `7 / 2` die Gleitkommazahl `3.5` ergibt, erhalten wir bei `7 // 2` die ganze Zahl `3` (es wird stets abgerundet).
</div>
</details>
%% Cell type:markdown id: tags:
Wie auch schon in der vorherigen Aufgabe finden Sie anschließend Hinweise, die einzelne Schritte der Lösung erklären und aufzeigen, versuchen Sie zunächst die Aufgabe ohne Hilfe zu lösen und schauen Sie die Hinweise wenn nötig Schritt für Schritt an.
Benötigen Sie insgesamt die selbe Anzahl an Leerzeichen um die Zeichenkette zu zentrieren? Wie viele davon müssen vor der Zeichenkette stehen? Wie können Sie diese Anzahl berechnen?
</div>
</details>
%% Cell type:code id: tags:
```
# Schreiben Sie hier Ihre Funktion
```
%% Cell type:markdown id: tags:
*Hinweis: Mit dem Operator `//` können wir zwei ganze Zahlen so teilen, dass eine ganze Zahl (*integer*) herauskommt. Während `7 / 2` die Gleitkommazahl `3.5` ergibt, erhalten wir bei `7 // 2` die ganze Zahl `3` (es wird stets abgerundet).*
Ein Aufruf der Funktion mit den folgenden Argumenten:
Wenn Sie Ihren Lösungsweg mit einer möglichen Lösung vergleichen wollen, können Sie diese hier finden. Allerdings gibt es häufig mehr als einen Lösungsweg; wenn Ihre Lösung anders aussieht, ist dies nicht zwingend falsch. Wenn Sie sich unsicher sind, fragen Sie bitte nach:
%% Cell type:code id: tags:
```
def center(s):
space=(70 - len(s)) // 2
print(' ' * space + s)
center ("Das ist der Test")
```
%% Cell type:markdown id: tags:
### Aufgabe 2
Ein Funktionsobjekt ist ein Wert, den wir einer Variablen zuweisen 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:
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.
</div>
</details>
%% 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.
Haben Sie den Platzhalter für das 'Wertargument' an den Platzhalter der Funktion übergeben?
</div>
</details>
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!
Schreiben Sie `print_twice` und den Wert mit Kommas getrennt hintereinander in den Funktionsaufruf.
</div>
</details>
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! Rufen Sie die Funktion auf und testen Sie diese!
`do_four` muss die Werte lediglich direkt an `do_twice` weiterreichen, `do_twice` sollte bereits korrekt mit den Werten umgehen, wenn Sie die Aufgabe schrittweise gelöst haben.
</div>
</details>
%% Cell type:markdown id: tags:
Hier finden Sie die Lösung. Versuchen Sie es erst einmal zu zweit und gehen Sie Schritt für Schritt vor!
Zeichenketten lassen sich durch den Plus-Operator `+` verbinden.
Außerdem nimmt die `print()`-Funktion auch mehrere Argumente entgegen. Diese müssen durch Kommata getrennt werden:
`print("+", Variable, "-")`.
</div>
</details>
------------------------
Wenn Sie nicht wissen, wie Sie an die Aufgabe herangehen können, können Sie die folgenden Hinweise nutzen um den Anfang zu finden. Schauen Sie sich dabei immer so wenige Hinweise an, wie möglich.
Überlegen Sie sich, in welchem Muster die verschiedenen Zeilentypen angeordnet sind. Haben Sie bereits eine Funktion definiert, mit der Sie dieselbe Zeile mehrfach hintereinander ausgeben lassen können?
Wenn Sie eine Funktion definieren, die genau eine der Seiten (`| | |`) ausgibt, können Sie `do_four()` verwenden, um diese viermal hintereinander ausgeben zu lassen. Sie können sich dann noch überlegen, ob Sie die Querbalken manuell in der `grid()` Funktion aufschreiben oder ob Sie diese auch in eine Funktion packen und dann an der entsprechenden Stelle diese Funktion aufrufen.
</div>
</details>
Beachten Sie bitte, dass es fast immer mehr als einen Weg gibt, die Aufgaben zu lösen. Solange die Ausgabe stimmt, haben Sie wahrscheinlich alles richtig gemacht.
#### Aufgabe 3.2
Schreiben Sie eine ähnliche Funktion, die ein Gitter mit je 4 Reihen und Zeilen zeichnet.
Bevor Sie anfangen Ihre eigene Lösung zu entwickeln, schauen Sie sich den folgenden Code an und versuchen Sie zu verstehen, was er macht. Führen Sie ihn aus und beschreiben Sie, warum er die Aufgabe nicht löst.
Hier wird ein Gitter gezeichnet, welches auch aus 4 Kästchen besteht, die aber viel kleiner sind als die Kästchen in Aufgabenteil 1. In dieser Aufgabe wird nicht verlangt, dass die Kästchengröße verändert wird. Es sollen stattdessen insgesamt 16 Kästchen gezeichnet werden, das Muster soll sich also vergrößern, nicht verkleinern.
</div>
</details>
Wenn Sie verstanden haben, warum die obige Lösung nicht korrekt ist, können Sie versuchen, eine korrekte Lösung zu entwickeln.
Überlegen Sie zunächst, wie das gewünschte Gitter aussehen soll. Wie unterscheidet es sich von dem ersten Gitter? Erstellen Sie eventuell per Hand eine grobe Skizze, damit Sie sich anschauen können, wo sich das Muster wiederholt.
Zuerst müssen wir die beiden Zeilentypen korrekt erstellen. Dafür könnten wir schlicht und ergreifend jeweils die Zeile einmal aufschreiben. Dieser Ansatz ist aber sehr fehleranfällig, stattdessen ist es besser, wenn wir mit der Verkettung durch `*` und `+` arbeiten.
Um die Zeile optimiert aufzuschreiben, können Sie eine Variable erstellen und ihr das erste Viertel der Zeile zuweisen. Dann können Sie mit Hilfe von Verkettung dieses Viertel vier mal ausgeben und mit dem Schlusszeichen abschließen.
Überlegen Sie sich, was Sie aus der vorherigen Lösung übernehmen können, um das Gitter darzustellen. Wie müssen Sie die Zeilenwiederholung anpassen, damit das korrekte Ergebnis angezeigt wird?
Auch wenn diese Version funktioniert, ist sie doch nicht sehr effektiv und wir können Sie verbessern. Eine Folge von Anweisungen wird 4 mal ausgeführt. Wenn wir diese Folge in eine eigene Funktion packen, können wir `do_four()` verwenden, um diese Folge viermal auszuführen und unseren Code somit beträchtlich kürzen.
</div>
</details>
%% Cell type:markdown id: tags:
Wie gehabt, folgt jetzt die Lösung. Lesen Sie erst weiter, wenn Sie die Aufgabe gelöst haben und sich eine Musterlösung anschauen wollen. Nutzen Sie zunächst die Hinweise, die Sie weiter oben im Text finden, um Ihre eigene Lösung zu entwickeln.
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 | 2 |
| 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 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:
- Ein Produkt aus möglichst vielen 3en ergibt das beste Ergebnis.
- Falls es nicht ganz aufgeht, mit 2 oder 4 auffüllen.
Erklärung:
- Ob wir eine 4 oder zwei 2en 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 neue 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.
([Python](https://xkcd.com/353/), Randall Munroe)
%% Cell type:markdown id: tags:
 Speichern Sie dieses Notebook, sodass Ihre Änderungen nicht verloren gehen (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/).
Dieses Notebook ist als freies Werk unter der Lizenz [Creative Commons Attribution-NonCommercial 3.0 Unported](http://creativecommons.org/licenses/by-nc/3.0/) verfügbar. Sie dürfen die Inhalte kopieren, verteilen und verändern, solange Sie die Urheber nennen und sie nicht für kommerzielle Zwecke nutzen.
