===== Funktionen =====

++++Links zu Online-Tutorials|

   * Dreiteiliges Tutorial zum Thema Funktionen vom Kanal "Programmieren Starten":
     * Funktionen: [[https://youtu.be/LQCfN5HS9xI]]
     * Funktionen mit Parametern: [[https://youtu.be/af9ORp1Pty0]]
     * Funktionen mit Rückgabewert: [[https://youtu.be/ehSP-sYoKCY]]

++++

Wir haben gesehen, dass man mit einer while-Schleife den gleichen Codeblock mehrfach hintereinander ausführen kann. Was ist nun aber, wenn man den gleichen Codeblock //nicht// direkt hintereinander, sondern an verschiedenen Orten im Code aufrufen möchte? Nach unserem jetztigen Wissensstand bleibt uns nur Copy-Paste! Gleichzeitig wissen wir aber, dass wir uns schlecht fühlen sollen, wenn wir dies machen! Damit wir uns nicht schlecht fühlen müssen, wurden **Funktionen** erfunden: Diese erlauben es uns, den gleichen Codeblock von verschiedenen Stellen im Code aufzurufen. Funktionen sind auch nützlich, um komplexe Programme in kleinere, leichter zu programmierende Teilprogramme zu zerlegen.

Beispiele:
   * In einem Zahlenspiel wollen wir oft überprüfen, ob eine Benutzereingabe eine nicht-negative Zahl ist. Diese Überprüfung könnte man in eine Funktion `check_user_input(...)` 'aussourcen'.
   * Du möchtest oft die gleiche Art Rechnung ausführen, z.B. eine lineare Gleichung lösen -> Funktion `linear_equation_solver(...)`

Übrigens hast du schon viele Funktionen kennengelernt - ohne dass du es wahrscheinlich gemerkt hast. Zum Beispiel ist die Funktion `forward(...)` für Turtles eine Funktion, die ein Turtle eine gewisse Anzahl Pixel vorwärts laufen lässt.

In Python wird eine Funktion wie folgt programmiert:
<code python>
def name_der_funktion(PARAMETER): # Parameter sind optional
    # Codeblock der Funktion
    return <Resultat>  # optional
</code>

   * Das Schlüsselwort `def` leitet immer die Definition einer Funktion ein.
   * Darauf folgt der **Funktionsname**. Typischerweise schreibt man diesen mit ausschliesslich Kleinbuchstaben und Underscores `_`.
     * Wie bei Variablen bestimmst du den Namen - er sollte sinnvoll sein und beschreiben, was die Funktion tut.
   * Direkt anschliessend werden `(`**runde Klammern**`)` geschrieben. Diese enthalten die **Parameter**. Das sind Werte, die an die Funktion übergeben werden. Funktionen können auch ohne Parameter definiert werden, die Klammern sind dann leer.
   * Nach einem **Doppelpunkt** `:`
   * folgt der **Funktionskörper**, der den eigentlichen Code der Funktion beinhaltet. Dieser Code muss **eingerückt** sein.
   * Eine Funktion kann (muss aber nicht) mit `return` etwas **zurückgeben**.

Nachdem du eine Funktion definiert hast, kannst du sie ganz einfach aufrufen. Dazu mehr in den Beispielen unten.

=== Beispiel 1: Funktion ohne Parameter und Rückgabewert ===

Die Funktion gibt einfach "Hallo du!" aus, wenn sie aufgerufen wird. Die ersten beiden Zeilen definieren die Funktion. Unten wird sie zweimal aufgerufen, dementsprechend wird 2x "Hallo du!" ausgegeben.

<bottom-editor>
def say_hi():
    print("Hallo du!")

say_hi()
say_hi()
</bottom-editor>

=== Beispiel 2: Funktion mit Parameter und ohne Rückgabewert ===

Nun soll unsere Begrüss-Funktion persönlicher werden. Wir wollen sowohl Silvia wie auch Gabriele grüssen. Der Code dazu ist identisch, mit Ausnahme des Namens. Dazu können wir der Funktion ein **Argument** (hier: den Namen) übergeben. Dazu müssen wir die Funktion 'vorwarnen': In den runden Klammern schreiben wir einen Parameter hinein, hier `name` in `def say_hi(name)`. Dies sagt der Funktion, dass man ihr ein Argument übergeben muss. Wird der Funktionskörper ausgeführt, ist der Parameter `name` wie eine gewöhnliche Variable, die den Wert im Aufruf übergebenen Arguments trägt.

Beim ersten Funktionsaufruf unten hat `name` also den Wert `"Silvia"` und beim zweiten den Wert `"Gabriele"`.

<bottom-editor>
def say_hi(name):
    print(f"Hallo {name}!")

say_hi("Silvia")
say_hi("Gabriele")
</bottom-editor>

=== Beispiel 3: Funktion ohne Parameter aber mit Rückgabewert ===

In einem Glücksspiel wollen wir oft einen Würfelwurf simulieren. Dazu wollen wir eine Würfelfunktion `wuerfle()` programmieren, die uns eine Zufallszahl von $1$ bis $6$ gibt:
<bottom-editor>
import random

def wuerfle():
    rand_nr = random.randint(1,6)
    return rand_nr

print(wuerfle())
print(wuerfle())
print(wuerfle())
</bottom-editor>

=== Beispiel 4: Funktion mit Parameter und mit Rückgabewert ===

Nun wollen wir auch andere Würfel (z.B. 12er-Würfel) simulieren können. Dazu führen wir einen Parameter ein, der den maximalen Wert des Würfels festlegt:
<bottom-editor>
import random

def wuerfle(max_nr):
    rand_nr = random.randint(1,max_nr)
    return rand_nr

print(wuerfle(12))
print(wuerfle(12))
print(wuerfle(12))
</bottom-editor>

In Realität ist es aber so, dass die meisten Würfel bis $6$ gehen. Wir können nun unser Leben einfacher machen, indem wir den Parameter `max_nr` mit einem **Vorgabewert** ausstatten:

<bottom-editor>
import random

def wuerfle(max_nr=6):
    rand_nr = random.randint(1,max_nr)
    return rand_nr

print(wuerfle(12)) # 12er-Wuerfel
print(wuerfle())   # 6er-Wuerfel, verwendet Vorgabewert
</bottom-editor>

Der erste Funktionsaufruf simuliert natürlich einen 12er-Würfel. Der zweite einen 6er-Würfel: Da kein Argument für den Parameter `max_nr` übergeben wird, wird der Vorgabewert (`max_nr=6`) verwendet. Hier ist es üblich, //keinen// Abstand links und rechts vom Operator zu machen.

==== Aufgaben E ====

**Vorwissen:**
   * [[gf_informatik:funktionen|Funktionen]]
   * Bis und mit Beispiel 2 "Funktion mit Parameter und ohne Rückgabewert"

Bei diesen Aufgaben geht es um folgendes:

   * Verstehen, was Funktionen sind und wozu sie nützlich sind
   * einfache Funktionen programmieren

=== Aufgabe E1 ===

<bottom-exercise id="e1">
<div slot="prompt">
<b>Nette Begrüssung:</b> Schreibe eine Funktion, der man den Namen und den Wohnort einer Person als Argumente übergibt. Die Funktion begrüsst diese Person dann ganz herzlich. Beispiel: <code>"Hallo, mein lieber Oskar aus Amriswil, ich wünsche dir einen ganz tollen Tag!"</code>
</div>
<template data-type="solution">
def greetings(name,residence):
    print(f"Hallo, mein(e) liebe(r) {name} aus {residence}. Ich wünsche dir einen ganz tollen Tag!")

greetings("Fritz", "Romanshorn")
greetings("Monika", "Amriswil")
</template>
</bottom-exercise>

=== Aufgabe E2 ===

<bottom-exercise id="e2">
<div slot="prompt">
Schreibe eine Funktion <code>head_or_tail()</code>, die einen Münzenwurf simuliert. Zufällig soll Kopf oder Zahl ausgewählt und ausgegeben werden.
</div>
<template data-type="solution">
import random

# Wichtig: Die Ermittlung der Zufallszahl mit randint und die
# Verzweigung (Kopf oder Zahl) muss IN der Funktion gemacht
# werden, nicht ausserhalb!

def head_or_tail():
    r = random.randint(1,2)
    if r == 1:
        print("Head!")
    else:
        print("Tail!")

head_or_tail()
head_or_tail()
</template>
</bottom-exercise>

<nodisp 1>
++++Tipps:|
Erzeuge mithilfe des `random`-Moduls eine [[gf_informatik:programmieren_ii#zufallszahlen|Zufallszahl]] ($1$ oder $2$). Falls die Zufallszahl $1$ ($2$) ist, gibst du "Zahl" ("Kopf") aus. Verwende dazu eine Verzweigung.

Simuliere nun 20 Münzenwürfe.
++++
</nodisp>


=== Aufgabe E3 ===

<bottom-exercise id="e3">
<div slot="prompt">
Schreibe eine Funktion <code>fortune_cookie()</code>, die ein Glückskeks-Spruch-Generator ist: Jedesmal wenn die Funktion aufgerufen wird, wird zufällig einer von mehreren Sprüchen ausgewählt und ausgegeben. Erfinde selber Sprüche oder klaue sie dreist aus dem Internet.
<p>
Rufe die Funktion auf.
</div>
<template data-type="solution">
import random

def fortune_cookie():
    r = random.randint(1,3)
    if r == 1:
        print("Morgenstund ist aller Laster anfang!")
    elif r == 2:
        print("Der Apfel fällt nicht weit vom Birnbaum!")
    else:
        print("Wer andern in der Nase bohrt, ist selbst ein Schwein.")

fortune_cookie()
</template>
</bottom-exercise>

<nodisp 1>
++++Tipps:|
Ähnlich wie Münzwurf-Funktion oben. Bestimme wieder eine Zufallszahl (z.B. im Bereich $1-5$, falls du fünf Sprüche hast). Falls die Zufallszahl $2$ ist, gibst du den zweiten Spruch aus. Verwende dazu eine if-elif-...-else-Verzweigung.
++++
</nodisp>

=== Aufgabe E4 ===

<bottom-exercise id="e3" layout="canvas" showswitcher>
<div slot="prompt">
TurtleGraphics: Schreibe eine Funktion <code>square(x)</code>, die eine Zahl <code>x</code> als Argument entgegen nimmt und ein Quadrat mit dieser Länge zeichnet.
</div>
<template data-type="solution">
from turtle import *
turi = Turtle()
turi.hideturtle()
turi.speed(1000)

def square(l):
    i = 0
    while i < 4:
        turi.forward(l)
        turi.right(90)
        i = i + 1

square(50)
square(100)
square(150)
square(200)
</template>
</bottom-exercise>

=== Aufgabe E5 ===

<bottom-exercise id="e5" layout="canvas" showswitcher style="max-height:40lh;">
<div slot="prompt">
Schreibe folgende Funktionen:
<ul>
   <li><code>square(x,y,l)</code>: Zeichnet Quadrat mit Seitenlänge l, startend an Position <code>x,y</code>
   <li><code>circle(x,y,r)</code>: Zeichnet Kreis mit Radius r, startend an Position <code>x,y</code>
   <li><code>rectange(x,y,a,b)</code>: Zeichnet Rechteck mit Seitenlängen a und b, startend an Position <code>x,y</code>
   <li><code>triangle(x,y,l)</code>: Zeichnet gleichseitiges Dreieck mit Seitenlänge l, startend an Position <code>x,y</code>
   <li>Funktion für selbst gewählte geometrische Figur
</ul>
<p>Mache nun moderne Kunst, indem du diese Funktionen aufrufst.

<p><b>Challenge (optional):</b> Erstelle mit möglichst vielen Zufallswerten moderne Kunst. Ziel: Kunst von deinem Programm soll besser und schöner sein als die vom Programm der Lehrperson!

<p>Vom Zufall abhängen können z.B. folgende Werte:
<ul>
   <li>Anzahl, wie oft jede Funktion aufgerufen wird.
   <li>Position von Figuren
   <li>Grössen von Figuren
   <li>Drehung von Figuren
   <li>Farben (Stift- und Füllfarbe), dazu kannst du den Funktionen weitere Argumente übergeben
</ul>
Tipps:
<ul>
   <li>Es lohnt sich, z.B. eine Funktion `draw_random_shape()` zu definieren, die dann zufällig eine der Formen zeichnet.
   <li>Du kannst auch weitere Funktionen definieren, die dir das Leben erleichtern.
</ul>
</div>
<template data-type="solution">
import random
from turtle import *

def square(t,l):
    i = 0
    while i < 4:
        t.fd(l)
        t.right(90)
        i = i + 1

def circle(t,r):
    t.circle(r)

def rectangle(t,a,b):
    i = 0
    while i < 2:
        t.fd(a)
        t.right(90)
        t.fd(b)
        t.right(90)
        i = i + 1

def triangle(t,l):
    i = 0
    while i < 3:
        t.fd(l)
        t.right(120)
        i = i + 1

def random_color(transparent=False):
    red = random.randint(1, 255)
    green = random.randint(1, 255)
    blue = random.randint(1, 255)
    if transparent:
        alpha = random.randint(50, 255)
        return (red, green, blue, alpha)
    else:
        return (red, green, blue)

def artist(t):
    shapes = random.randint(4,10)
    while shapes > 0:
        shapes = shapes - 1
        shape = random.randint(1, 4)
        angle = random.randint(0, 90)
        t.left(angle)
        x = random.randint(-180, 180)
        y = random.randint(-180, 180)
        t.teleport(x, y)
        side1 = random.randint(20, 100)
        t.fillcolor(random_color(True))
        t.width(0)
        t.begin_fill()
        if shape == 1:
            square(t, side1)
        elif shape == 2:
            circle(t, side1)
        elif shape == 3:
            triangle(t, side1)
        elif shape == 4:
            side2 = random.randint(20, 100)
            rectangle(t, side1, side2)
        t.end_fill()

t = Turtle()
t.hideturtle()
t.speed(100)

artist(t)
</template>
</bottom-exercise>

==== Aufgaben F ====

**Vorwissen:**
   * [[gf_informatik:funktionen|Funktionen]]
   * Bis und mit Beispiel 4 "Funktion mit Parameter und Rückgabewert"

Bei diesen Aufgaben geht es um folgendes:

   * Funktionen mit Rückgabewert verstehen und anwenden.
   * Lernen, wann man eine Funktion (k)einen Rückgabewert haben sollte.

=== Aufgabe F1 ===

<bottom-exercise id="f1">
<div slot="prompt">
Schreibe folgende Funktionen:

<p>Definiere eine Funktion mit einem Argument <code>volume_cube(x)</code>, die das Volumen eines Würfels mit Seitenlänge <code>x</code> (in cm) berechnet und zurückgibt (also NICHT printed). Speichere das Resultat in einer Variablen und gebe es dann aus.

<p>Welches Volumen hat ein Würfel mit Seitenlänge 13 cm?
</div>
<template data-type="solution">
def volume_cube(x):
    return x**3

v = volume_cube(13)
print(v)
</template>
<template data-type="test">
assert volume_cube(13) == 2197
assert volume_cube(4) == 64
</template>
</bottom-exercise>

=== Aufgabe F2 ===

<bottom-exercise id="f2">
<div slot="prompt">
<b>Satz von Pythagoras:</b> Schreibe eine Funktion <code>pythagoras(a,b)</code>, mit der du die Hypotenuse eines rechtwinkligen Dreiecks mit Katheten <code>a</code> und <code>b</code> berechnen kannst. Das Resultat soll <em>zurückgegeben</em> werden.  

<p><b>Tipp:</b> Die Wurzel einer Zahl ziehst du mit <code>sqrt(x)</code>, dazu musst du aber zuerst das math-Modul importieren: <code>import math</code>.

<p><b>Kontrolle:</b> Für die Katheten 3 und 4 ist die Hypothenuse 5. Die Codezeile <code>print(pythagoras(3,4))</code> soll dann also <code>5.0</code> ausgeben.
</div>
<template data-type="solution">
import math
def pythagoras(a,b):
    return math.sqrt(a*a + b*b)

print(pythagoras(3,4))
</template>
<template data-type="test">
assert pythagoras(3, 4) == 5.0
assert pythagoras(8, 15) == 17.0
</template>
</bottom-exercise>

=== Aufgabe F3 ===

Das Volumen einer Kugel mit Radius $R$ ist: $$V = \frac{4\pi}{3}\cdot R^3$$
<bottom-exercise id="f3">
<div slot="prompt">
Definiere eine Funktion <code>volume_sphere(...)</code>, der man als Argument den Radius übergibt und die dann das Volumen zurückgibt. Die Kreiszahl Pi (π) kannst du mit <code>math.pi</code> aufrufen, dazu muss aber auch wieder zuerst das math-Modul importiert werden (<code>import math</code>).
</div>
<template data-type="solution">
import math
def volume_sphere(r):
    return 4*math.pi/3 * r**3

print(volume_sphere(3))
</template>
<template data-type="test">
assert 113.09 < volume_sphere(3) < 113.099
</template>
</bottom-exercise>

=== Aufgabe F4 ===

Schreibe eine Funktion `grade(points)`, die dir die Note (_en_. grade) für eine gegebene Punktzahl berechnet und zurückgibt. Lege die Punktzahl, die für die Note $6$ notwendig ist in einer Konstanten (wie Variable, aber alles Grossbuchstaben) fest. Die Formel geht wie folgt:
$$\text{Note} = \frac{5 \cdot \text{(erreichte Punkte)}}{\text{Punktzahl für Note 6}} + 1$$

Beachte:
   * Um die Noten schön zu runden, kannst du die //vordefinierte Funktion// `round` verwenden: `round(3.14159,2)` rundet dir die Zahl $3.14159$ auf zwei Nachkommastellen, man erhält also $3.14$.
   * Erreicht man mehr Punkte als notwendig für Note 6, soll man trotzdem die Note 6 erhalten.

<bottom-exercise id="f4">
<template data-type="solution">
def grade(points,points_6):
    gr = 5*points/points_6 + 1
    if gr > 6:
        gr = 6.0
    return round(gr,1)

print(grade(23,51))
</template>
</bottom-exercise>

=== Aufgabe F5 ===

Die **Fakultät** ist eine Funktion, welche jeder ganzen natürlichen Zahl das Produkt aller natürlichen Zahlen (ohne Null) kleiner und gleich dieser Zahl zuordnet. Sie wird mit einem Ausrufezeichen geschrieben. Als Beispiel: $5!=1 \cdot 2 \cdot 3 \cdot 4 \cdot 5 =120$.

<bottom-exercise id="f5">
<div slot="prompt">
Schreibe eine Funktion <code>factorial(...)</code>, der als Argument eine ganze Zahl übergeben wird und die dir dann die Fakultät dieser Zahl zurückgibt.

<p><b>Optionale Challenge für absolute Freaks</b>: Kannst du die Fakultät ganz ohne Schleife berechnen? Dann hast du das Prinzip der <em>Rekursion</em> (Selbst-Aufruf) entdeckt!
</div>
<template data-type="solution">
def factorial(n):
    product = 1
    i = 1
    while i <= n:
         product = product * i
         i = i + 1
    return product

print(factorial(5))
</template>
<template data-type="test">
assert factorial(5) == 120
assert factorial(10) == 3628800
</template>
</bottom-exercise>

=== Aufgabe F6 (optional) ===

**Mitternachtsformel:** Eine quadratische Funktion kann immer in die Form $$ax^2 + bx + c = 0$$ gebracht werden. Die Lösung ist gegeben durch:
$$x = \frac{-b \pm \sqrt{b^2-4ac}}{2a}$$

Schreibe eine Funktion `mitternachtsformel(...)`, die die drei Werte für $a,b,c$ entgegennimmt und die Lösung(en) zurück gibt. Beachte, dass es drei Fälle gibt:
   * keine Lösung: gib `None` zurück, dies ist der Fall, wenn der Term in der Wurzel negativ ist
   * eine Lösung, dies ist der Fall, wenn der Term in der Wurzel genau 0 ist
   * zwei Lösungen: gib beide Werte (mit Komma getrennt) zurück

Tipp: Verwende die Diskriminante, um den richtigen Fall zu ermitteln.

Kontrolle: Die quadratische Gleichung ...

   * $3 x^2 - 6 x - 5 = 0$ hat die zwei Lösungen: $-0.632993$ und $2.63299$
   * $x^2 - 4 x + 4 = 0$ hat eine Lösung: $2$
   * $x^2 + 2 x + 7 = 0$ hat keine Lösung

<bottom-exercise id="f6">
<template data-type="solution">
from math import *
def mitternachtsformel(a,b,c):
    d = b*b - 4*a*c
    if d < 0:
        return None
    elif d == 0:
        return -b / (2*a)    
    else:
        r = -b / (2*a)
        return (-b - sqrt(d)) / (2*a), (-b + sqrt(d)) / (2*a)

print(mitternachtsformel(3,-6,-5)) # 2 Loesungen
print(mitternachtsformel(1,-4,4))  # 1 Loesung
print(mitternachtsformel(1,2,7))   # keine Loesung
</template>
<template data-type="test">
assert set(mitternachtsformel(3,-6,-5)) == {-0.632993161855452, 2.632993161855452}
assert mitternachtsformel(1,-4,4) == 2
assert mitternachtsformel(1,2,7) == None
</template>
</bottom-exercise>