Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

--- gf_informatik:funktionen [2023-11-16 14:16] – [Definition] hof
+++ gf_informatik:funktionen [2024-12-02 14:09] (aktuell) – hof
@@ Zeile 1: / Zeile 1: @@
 ===== Funktionen =====
-Komplexe Programme können mit Hilfe von Funktionen in kleinere, leichter zu programmierende Teilprogramme zerlegt werden. Solche Teilprogramme können zudem mehrmals verwendet werden.
+++++Links zu Online-Tutorials|
-==== Definition ====
+   * 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]]
-Eine **Funktion** ist immer wie folgt aufgebaut:
+++++
+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
+def name_der_funktion(PARAMETER): # Parameter sind optional
-    # CODE DER FUNKTION
+    # Codeblock der Funktion
-    return RETURN_WERT  # optional
+    return <Resultat>  # optional
 </code>
-   * Das Schlüsselwort **def** leitet immer die Definition einer Funktion ein.
+   * Das Schlüsselwort `def` leitet immer die Definition einer Funktion ein.
-   * Darauf folgt der **Funktionsname**. Typischerweise schreibt man diesen mit ausschliesslich Kleinbuchstaben und Underlines _
+   * Darauf folgt der **Funktionsname**. Typischerweise schreibt man diesen mit ausschliesslich Kleinbuchstaben und Underscores `_`.
-   * 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 halt einfach leer.
+   * 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 halt einfach leer.
-   * Nach einem **Doppelpunkt** ...
+   * Nach einem **Doppelpunkt** `:`
-   * kommt der **Funktionskörper**, welcher den eigentlichen Code der Funktion beinhaltet. Dieser Code muss **eingerückt** sein.
+   * 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.
-Ü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 vorwärts laufen lässt. Diese Funktion wurde vorprogrammiert. Nun wollen wir schauen, wie wir unsere eigenen Funktionen definieren können.
+=== Beispiel 1: Funktion ohne Parameter und Rückgabewert ===
-==== Funktionen ohne 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.
+<code python>
+def say_hi():
+    print("Hallo du!")
-In diesem Unterkapitel schauen wir Funktionen ohne Rückgabewert an, also Funktionen ohne das `return`-Statement am Ende.
+say_hi()
+say_hi()
+</code>
-**Beispiel:** Du möchtest das gleiche Quadrat mehrfach zeichnen. Dies kannst du wie folgt machen:
+=== Beispiel 2: Funktion mit Parameter und ohne Rückgabewert ===
-<code python>
+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.
-from turtle import *
-fritz = Turtle()
+Beim ersten Funktionsaufruf unten hat `name` also den Wert `"Silvia"` und beim zweiten den Wert `"Gabriele"`.
-fritz.hideturtle()
-# Quadrat 1
+<code python>
-fritz.setpos(-130,0)
+def say_hi(name):
-repeat 4:
+    print("Hallo " + name + "!")
-    fritz.forward(100)
-    fritz.left(90)
-# Quadrat 2
+say_hi("Silvia")
-fritz.setpos(0,0)
+say_hi("Gabriele")
-repeat 4:
-    fritz.forward(100)
-    fritz.left(90)
 </code>
-Es fällt auf, das hier zweimal der //identische// Code vorkommt:
+=== 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:
 <code python>
-repeat 4:
+import random
-    fritz.forward(100)
-    fritz.left(90)
+def wuerfle():
+    rand_nr = random.randint(1,6)
+    return rand_nr
+print(wuerfle())
+print(wuerfle())
+print(wuerfle())
 </code>
-Dies ist nicht sehr elegant. Wenn man nun das gleiche Quadrat zehnmal zeichnen möchte, wird es noch viel schlimmer! Es lohnt sich deshalb hier, eine Funktion //quadrat// zu definieren und diese dann mehrfach aufzurufen:
+=== 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:
 <code python>
-from turtle import *
+import random
-fritz = Turtle()
+def wuerfle(max_nr):
-fritz.hideturtle()
+    rand_nr = random.randint(1,max_nr)
+    return rand_nr
-def quadrat():
+print(wuerfle(12))
-    repeat 4:
+print(wuerfle(12))
-        fritz.forward(100)
+print(wuerfle(12))
-        fritz.left(90)
-# Quadrat 1
-fritz.setpos(-130,0)
-quadrat()
-# Quadrat 2
-fritz.setpos(0,0)
-quadrat()
 </code>
-Beachte, dass in obigem Code jeweils zuerst die Position der Turtle festgelegt wird, bevor die Funktion aufgerufen wird. Noch eleganter wäre es, wenn das Setzen der Position //in der Funktion// geschieht. Die Koordinaten könnten dann der Funktion als **Argument** übergeben werden:
+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:
 <code python>
-from turtle import *
+import random
-fritz = Turtle()
-fritz.hideturtle()
-def quadrat(x,y):
-    fritz.setpos(x,y)
-    repeat 4:
-        fritz.forward(100)
-        fritz.left(90)
-# Quadrat 1
-quadrat(-130,0)
-# Quadrat 2
-quadrat(0,0)
-</code>
-Du kannst der Funktion auch noch weitere Argumente übergeben, zum Beispiel um die Grösse des Quadrats und dessen Farbe anzugeben:
+def wuerfle(max_nr=6):
+    rand_nr = random.randint(1,max_nr)
+    return rand_nr
-<code python>
+print(wuerfle(12)) # 12er-Wuerfel
-from turtle import *
+print(wuerfle())   # 6er-Wuerfel, verwendet Vorgabewert
-fritz = Turtle()
-fritz.hideturtle()
-def quadrat(x,y,seite,farbe):
-    fritz.setpos(x,y)
-    fritz.pencolor(farbe)
-    repeat 4:
-        fritz.forward(seite)
-        fritz.left(90)
-# Quadrat 1
-quadrat(-130,0,70,"red")
-# Quadrat 2
-quadrat(0,0,100,"magenta")
 </code>
+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.
-==== Funktionen mit Rückgabewert ====
+==== Aufgaben E ====
-Funktionen bieten sich auch an, wenn man mehrfach die gleiche Rechnung, einfach mit verschiedenen Werten, ausführen möchte. Allerdings möchte man dann, dass die Funktion einem das Resultat als **Rückgabewert** zurück gibt.
+**Vorwissen:**
+   * [[gf_informatik:funktionen|Funktionen]]
+   * Bis und mit Beispiel 2 "Funktion mit Parameter und ohne Rückgabewert"
-**Beispiel:** Wir wollen eine Funktion definieren, die uns das Volumen eines Quaders zurück gibt. Falls der Quader die Seitenlängen $a,b$ und $c$ hat, so ist sein Volumen
+Bei diesen Aufgaben geht es um folgendes:
-$$V = a \cdot b \cdot c$$
-Die zugehörige Funktion ist dann:
-<code python quader.py>
-def quader(a,b,c):
-    resultat = a*b*c
-    return resultat
-print(quader(4,3,2))
-</code>
-Auf der letzten Zeile wird das Volumen für einen Quader mit Seitenlängen $4, 3$ und $2$ berechnet und dann in der Konsole ausgegeben.
-==== Probleme mit Funktionen ====
+   * Verstehen, was Funktionen sind und wozu sie nützlich sind
-[[gf_informatik:funktionen:problems|Probleme mit Funktionen]]
+   * einfache Funktionen programmieren
-==== Aufgaben G – Funktionen ohne/mit Rückgabewert ====
-=== Aufgabe G1 ===
+=== Aufgabe E1 ===
-Für diese Aufgabe benötigst du Turtle graphics.
+**Nette Begrüssung:** 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: "Hallo, mein lieber Oskar aus Amriswil, ich wünsche dir einen ganz tollen Tag!"
-  - Definiere eine Funktion namens ''spirale()''. Diese zeichnet eine beliebige Spirale aus mindestens 6 Halbkreisen.
+=== Aufgabe E2 ===
-  - Rufe im Code die Funkton ''spirale()'' mindestens dreimal auf. Ändere vorher jeweils die Position deiner Turtle (mit ''setpos()''), sodass die drei Spiralen an unterschiedlichen Orten gezeichnet werden.
-=== Aufgabe G2 ===
+Schreibe eine Funktion `head_or_tail()`, die einen Münzenwurf simuliert. Zufällig soll Kopf oder Zahl ausgewählt und ausgegeben werden.
-  - Erweitere die Funktion ''spirale()'' aus obiger Aufgabe in die Funktion ''spirale(x, y)'': Neu sollst du der Funktion die Startposition (x- und y-Koordinate) übergeben können.
+<nodisp 1>
-  - Rufe im Code die Funkton ''spirale()'' mindestens drei mal auf, sodass die drei Spiralen an unterschiedlichen Orten gezeichnet werden.
+++++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.
+++++
+</nodisp>
-=== Aufgabe G3 ===
-  - Erweitere die Funktion ''spirale()'' erneut: Neu sollst du der Funktion neben der Startposition (x- und y-Koordinate) auch die Anzahl Halbkreise und die Grösse des Radius des kleinsten Halbkreises übergeben können.
+=== Aufgabe E3 ===
-  - Rufe im Code die Funkton ''spirale()'' mindestens drei mal mit unterschiedlichen Parametern auf.
+Schreibe eine Funktion `fortune_cookie()`, 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.
-=== Aufgabe G4 ===
+Rufe die Funktion auf.
-Für diese Aufgabe benötigst du Turtle graphics. Definiere folgende Funktionen:
+<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.
-   * quadrat(turtle, seitenlaenge, farbe, x, y)
+Simuliere nun 20 Münzenwürfe.
-   * dreieck(turtle, seitenlaenge, farbe, x, y)
+++++
-   * kreis(turtle, radius, farbe, x, y)
+</nodisp>
-Ruft man z.B. die Funktion `dreieck(michelangelo, 100, "red", -200, 50)` auf, soll die Turtle namens //michelangelo// ein //rotes// Dreieck mit Seitenlänge //100// und Startpunkt //(-200,50)// zeichnen. **Wichtig:** Die Turtle muss zuerst erstellt werden (z.B.: ''michelangelo = Turtle()''), damit sie der Funktion übergeben werden kann.
+=== Aufgabe E4 ===
-Zeichne mit diesen Funktionen ein Bild. Jede der drei Formen soll mindestens 3 mal vorkommen. Variiere die Farbe und Grösse der Formen.
+TurtleGraphics: Schreibe eine Funktion `square(x)`, die eine Zahl $x$ als Argument entgegen nimmt und ein Quadrat mit dieser Länge zeichnet.
-== Erweiterung (Optional) ==
+=== Aufgabe E5 ===
-Erstelle ein Python Modul:
-  * Speichere die Geometrie-Funktionen in einer separaten Datei `geometrie.py`.
-  * Erstelle eine zweite Datei `g4.py` im selben Ordner.
-  * In `g4.py` importierst du das Geometrie-Modul mit `import geometrie`.
-  * Die importierten Funktionen müssen zur Verwendung qualifiziert werden, z.B. `geometrie.dreieck(...)`.
-  * Zeichne mit den Funktionen abstrakte Kunst (wie oben).
-<nodisp 1>
+Schreibe folgende Funktionen:
-++++Lösung|
+   * `square(x,y,l)`: Zeichnet Quadrat mit Seitenlänge l, startend an Position $(x,y)$
-<code python geometrie.py>
+   * `circle(x,y,r)`: Zeichnet Kreis mit Radius r, startend an Position $(x,y)$
-def vieleck(turtle, ecken, seite, farbe, x,y):
+   * `rectange(x,y,a,b)`: Zeichnet Rechteck mit Seitenlängen a und b, startend an Position $(x,y)$
-    turtle.setpos(x,y)
+   * `triangle(x,y,l)`: Zeichnet gleichseitiges Dreieck mit Seitenlänge l, startend an Position $(x,y)$
-    turtle.pencolor(farbe)
+   * Funktion für selbst gewählte geometrische Figur
-    # Aussenwinkel eines Vielecks summieren sich auf 360°
-    # https://de.wikipedia.org/wiki/Aussenwinkel
-    winkel = 360 / ecken
-    repeat ecken:
-        turtle.forward(seite)
-        turtle.left(winkel)
-def quadrat(turtle, breite, farbe, x, y):
+Mache nun moderne Kunst, indem du diese Funktionen aufrufst.
-    vieleck(turtle, 4, breite, farbe, x, y)
-def dreieck(turtle, breite, farbe, x, y):
-    vieleck(turtle, 3, breite, farbe, x, y)
-def kreis(turtle, radius, farbe, x, y):
+**Challenge (optional):** 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!
-    turtle.setPos(x,y)
-    turtle.setPenColor(farbe)
-    turtle.leftArc(radius, 360)
-</code>
-<code python kunst.py>
+ Vom Zufall abhängen können z.B. folgende Werte:
-import geometrie
+   * Anzahl, wie oft jede Funktion aufgerufen wird.
-from turtle import *
+   * Position von Figuren
+   * Grössen von Figuren
+   * Drehung von Figuren
+   * Farben (Stift- und Füllfarbe), dazu kannst du den Funktionen weitere Argumente übergeben
-t = Turtle()
+Tipps:
-t.hideturtle()
+   * Es lohnt sich, z.B. eine Funktion `draw_random_shape()` zu definieren, die dann zufällig eine der Formen zeichnet.
+   * Du kannst auch weitere Funktionen definieren, die dir das Leben erleichtern.
-geometrie.quadrat(t, 100, "red", 0, 0)
+<nodisp 1>
-geometrie.kreis(t, 50, "blue", 0, 50)
+++++Lösungen Aufgaben E|
-geometrie.dreieck(t, 75, "green", -100, 100)
-</code>
-++++
-</nodisp>
-=== Aufgabe G5 ===
-Kennt man in einem rechtwinkligen Dreieck die beiden Katheten, so kann man mit dem Satz von Pythagoras die Hypothenuse bestimmen. Definiere eine Funktion mit Namen //pythagoras//. Als Argumente soll man die beiden Katheten eines rechtwinkligen Dreiecks eingeben. Die Funktion berechnet dann die Hypothenuse und gibt diese mit //return// zurück.
+==== Aufgaben E ====
-//Tipp:// Die Wurzel einer Zahl ziehst du mit `sqrt(x)`, dazu musst du aber zuerst das math-Modul importieren: `import math`.
+=== Aufgabe E1 ===
-//Kontrolle:// Für die Katheten 3 und 4 ist die Hypothenuse 5. Die Codezeile `print(pythagoras(3,4))` soll dann also `5.0` ausgeben.
-<nodisp 1>
-++++Lösung|
 <code python>
-import math
+def greetings(name,residence):
-def pythagoras(a, b):
+    print("Hallo, mein(e) liebe(r) " + name + " aus " + residence + ". Ich wünsche dir einen ganz tollen Tag!")
-    return math.sqrt(a**2 + b**2)
-print(pythagoras(3,4))
+greetings("Fritz","Romanshorn")
+greetings("Monika","Amriswil")
 </code>
-++++
-</nodisp>
-=== Aufgabe G6 ===
-Das Volumen einer Kugel mit Radius $R$ ist: $$V = \frac{4\pi}{3}\cdot R^3$$
+=== Aufgabe E2 ===
-Definiere eine Funktion //kugel//, der man als Argument den Radius übergibt und die dann das Volumen zurückgibt. Die Kreiszahl Pi ($\pi$) kannst du mit `math.pi` aufrufen, dazu muss aber auch wieder zuerst das math-Modul importiert werden (`import math`).
-<nodisp 1>
-++++Lösung|
 <code python>
-import math
+import random
+"""
+Wichtig: Die Ermittlung der Zufallszahl mit randint und die Verzweigung (Kopf oder Zahl) muss IN der Funktion gemacht werden, nicht ausserhalb!
+"""
-def kugel_volumen(radius):
+def head_or_tail():
-    return 4 * math.pi / 3 * radius**3
+    r = random.randint(1,2)
+    if r == 1:
+        print("Head!")
+    else:
+        print("Tail!")
-print kugel_volumen(2)
+head_or_tail()
+head_or_tail()
 </code>
-++++
-</nodisp>
-=== Aufgabe G7 ===
-Definiere eine Funktion //wuerfel//, welche einen Würfel simuliert, d.h. eine Zufallszahl zwischen 1 und 6 mit //return// zurückgibt.
+=== Aufgabe E3 ===
-{{:gf_informatik:pasted:20230215-091017.png?150|}}
-<nodisp 1>
-++++Lösung|
 <code python>
 import random
-def wuerfel():
-    return random.randint(1,6)
-print(wuerfel())
+def fortune_cookie():
+    r = random.randint(1,3)
+    if r == 1:
+        print("Spruch 1")
+    elif r == 2:
+        print("Spruch 2")
+    else:
+        print("Spruch 3")
 </code>
-++++
-</nodisp>
-== Challenge (optional) ==
+=== Aufgabe E4 ===
-Simuliere mit TurtleGraphics einen Würfel.
-==== Aufgaben GA – Funktionen mit Algorithmen (ohne/mit Rückgabewert) ====
-=== Aufgabe GA1 – Fibonacci-Zahlen ===
+<code python>
-Schreibe eine Funkton namens //fibonacci_numbers//, die beliebig viele Elemente der [[https://de.wikipedia.org/wiki/Fibonacci-Folge|Fibonacci-Folge]] ausgibt.
+from turtle import *
+turi = Turtle()
+turi.hideturtle()
+turi.speed(1000)
-Zum Beispiel soll ''fibonacci_numbers(8)'' die ersten acht Elemente der Fibonacci-Folge ausgeben, also 0, 1, 1, 2, 3, 5, 8, 13. Teste die Funktion, indem du sie mit unterschiedlichen Werten aufrufst.
+def square(l):
+    i = 0
+    while i < 4:
+        turi.forward(l)
+        turi.right(90)
+        i = i + 1
-Tipp: Setze in der Funktion zuerst zwei Variablen a und b auf die ersten beiden Fibonacci-Zahlen (0 und 1) und gebe diese nacheinander aus. Erst jetzt beginnt eine sich wiederholende Abfolge von Code-Zeilen für die Ausgabe der weiteren Werte.
+square(50)
+square(100)
+square(150)
+square(200)
+</code>
+=== Aufgabe E5 ===
-<nodisp 1>
-++++Lösung|
 <code python>
-def fibonacci_numbers(anz):
+from turtle import *
-    a = 0
+t = Turtle()
-    b = 1
+t.hideturtle()
-    print a
-    print b
-    repeat anz-2:
-        c = a + b
-        print c
-        a = b
-        b = c
-fibonacci_numbers(8)
+def square(x,y,l):
+    t.teleport(x,y)
+    i = 0
+    while i < 4:
+        t.fd(l)
+        t.right(90)
+        i = i + 1
+def circle(x,y,r):
+    t.teleport(x,y)
+    t.circle(r)
+def rectangle(x,y,a,b):
+    t.teleport(x,y)
+    i = 0
+    while i < 2:
+        t.fd(a)
+        t.right(90)
+        t.fd(b)
+        t.right(90)
+        i = i + 1
+def triangle(x,y,l):
+    t.teleport(x,y)
+    i = 0
+    while i < 3:
+        t.fd(l)
+        t.right(120)
+        i = i + 1
+square(-200,-300,150)
+circle(0,150,40)
+rectangle(-150,50,20,100)
+triangle(100,150,40)
 </code>
+[[https://webtigerpython.ethz.ch/?code=NobwRAdghgtgpmAXGGUCWEB0AHAnmAGjABMoAXKJMNGbAewCcyACBqCYumAHQgDMGXZmQCuTADZxmNek2YAqXiwC8zACpiykgBQBKJZgAWaYnFES4egwGdscOMW0BGAAwv9EXqb7NrARxEoBksADwJcAnFdRF5mOOFMMjhJWTJtMNwPeOlmVRdY-IB3Y0kcgB5mABYYiGzsskw-RyiCuoSGNABzQzSATndWurRcnIBqZideLzgfAGM0BlmdDIIGaMGGpJTGNIys-Ib5xZ01qY4Z1jhZighO5fCCKAIAI3Xag8TkuFT08P244Z5QbFNClYYVABMNTacQaTW0UH-dQaHW6fQG7zacMcr0G9UwqJ62n6SOygLGEzO3mEHXYd1CDyi0I-W2-O1-mUG5PymOYILBzAqAGZmVjGs1SR9CWknBCMTCcqphuNJp5zj42BwuAB9WZ0cSMbRkTW2IJwCBkZQAMSg4mscDe2WCxBGms4MAJ7GIGBlBGYEIArAGkZ1gubXV6uJ6OD7nH7A8HBs9xCIpKo3VG3bGnPGg0i0D5jexTcELaK6rbsIYoBGtR6sxbtAGXLnE7ynWYxLVtM6_aH7BA_cnU37K9Wkcl7eWO-Zu73mP3zUOUw6qRcgmQ0NY0o74tZq3ZrLX3dHvY3KgRXEj-VJ91BD8wAHzMFzTvcHuBH1R3h8AWkp7bvveaasJG9ZetmfqVJKcR0qU6ZgaesYtswJJ4h8kh8GkcGroBcQhMemYQY2v5OAAHCh5HyjCuCEeBMYkVRfpUTBvgmHATh0UhjZysxbisXCoLiHqBoMD2YG6vqhpqAwqa6AJmCFCYZCGNo1Fis8cCdBg2p8EJVh4dIPg_mmqhOG-bT-IEwS_MwERsaYTisckBa-B-uSqFC6FtEcSwMnZfrWOxTnecwLnGe5yiqCKoX1LStz3AFDkcc54iuSZHlVBZdRBaYEJcQ2aS8RM_GxfEwTXDhtn2blHGBexEIKeaxC6fprHZLwG5bjuvBgAAvgAukAA|Modern Artist]]
 ++++
 </nodisp>
-=== Aufgabe GA2 – Fibonacci-Muster  ===
-Schreibe eine Funkton namens //fibonacci_arcs//, die eine Spirale aus Viertel-Kreisen zeichnet, deren Radien gemäss der [[https://de.wikipedia.org/wiki/Fibonacci-Folge|Fibonacci-Folge]] zunehmen.
-Zum Beispiel soll ''fibonacci_arcs(8)'' acht Viertelkreise zeichnen. **Beachte Folgendes:**
+==== Aufgaben F ====
-  * Hier soll die Fibonacci-Folge nicht mit 0, sondern mit 1 beginnen (a = b = 1).
-  * Multipliziere die Fibonacci-Zahlen mit einem Faktor, zum Beispiel 5, um den Radius zu erhalten.
-Teste die Funktion: ''fibonacci_arcs(9)'' sollte etwa folgendes Muster ergeben:
+**Vorwissen:**
+   * [[gf_informatik:funktionen|Funktionen]]
+   * Bis und mit Beispiel 4 "Funktion mit Parameter und Rückgabewert"
-{{:gf_informatik:pasted:20230214-194805.png?200|}}
+Bei diesen Aufgaben geht es um folgendes:
-<nodisp 1>
+   * Funktionen mit Rückgabewert verstehen und anwenden.
-++++Lösung|
+   * Lernen, wann man eine Funktion (k)einen Rückgabewert haben sollte.
-<code python>
-from turtle import *
-leonardo = Turtle()
-def fibonaci_arcs(n):
+=== Aufgabe F1 ===
-    a = b = 1
-    leonardo.circle(a*5, 180) # erste zwei Viertelkreise
-    repeat n-2:
-        c = a + b
-        leonardo.circle(c*5, 90)
-        a = b
-        b = c
-fibonaci_arcs(9)
+Definiere eine Funktion mit einem Argument `volume_cube(x)`, die das Volumen eines Würfels mit Seitenlänge $x$ (in cm) berechnet und zurückgibt (also NICHT printed). Speichere das Resultat in einer Variablen und gebe es dann aus.
-</code>
-++++
-</nodisp>
-=== Aufgabe GA3 – Fibonacci-Muster mit Zeitmessung ===
-Erweitere die Funktion //fibonacci_arcs// so, dass sie die Zeit zum Zeichnen des Musters misst und diesen Wert zurückgibt. Importiere dazu das //time//-Modul (''import time'') und nutze die Funktion ''time()'', um einen Zeitstempel in Sekunden zu erhalten:
-<code python>
+Welches Volumen hat ein Würfel mit Seitenlänge 13 cm?
-import time
-time1 = time.time()
-## some code that takes some time
-## ...
-time2 = time.time()
-time_passed = time2 - time1
-</code>
-Teste die Funktion zum Beispiel so:
+=== Aufgabe F2 ===
-<code python>
-print(fibonacci_arcs(9))
-</code>
-Damit sollte dein Code das Muster aus neun Viertelkreisen zeichnen und anschliessend die gemessene Anzahl Sekunden ausgeben.
+**Satz von Pythagoras:** Schreibe eine Funktion `pythagoras(a,b)`, mit der du die Hypotenuse eines rechtwinkligen Dreiecks mit Katheten $a$ und $b$ berechnen kannst. Das Resultat soll *zurückgegeben* werden.
-<nodisp 1>
+//Tipp:// Die Wurzel einer Zahl ziehst du mit `sqrt(x)`, dazu musst du aber zuerst das math-Modul importieren: `import math`.
-++++Lösung|
-<code python>
-import time
-from turtle import *
-leonardo = Turtle()
-def fibonaci_arcs(n):
+//Kontrolle:// Für die Katheten 3 und 4 ist die Hypothenuse 5. Die Codezeile `print(pythagoras(3,4))` soll dann also `5.0` ausgeben.
-    start_time = time.time()
-    a = b = 1
-    leonardo.circle(a*5, 180) # erste zwei Viertelkreise
-    repeat n-2:
-        c = a + b
-        leonardo.circle(c*5, 90)
-        a = b
-        b = c
-    return(time.time()-start_time)
-print(fibonaci_arcs(9))
-</code>
-++++
-</nodisp>
-=== Aufgabe GA4 ===
-Schreibe eine Funktion //summe\_ungerade//, die die Summe aller ungeraden Zahlen von 0 bis n zurückgibt.
+=== Aufgabe F3 ===
-Zum Beispiel soll ''summe\_ungerade(5)'' die Zahl 9 zurückgeben. Auch ''summe\_ungerade(6)'' soll natürlich 9 zurückgeben.
-//Tipp:// Verwende eine Zählvariable und eine While-Schleife.
+Das Volumen einer Kugel mit Radius $R$ ist: $$V = \frac{4\pi}{3}\cdot R^3$$
+Definiere eine Funktion `volume_sphere(...)`, der man als Argument den Radius übergibt und die dann das Volumen zurückgibt. Die Kreiszahl Pi ($\pi$) kannst du mit `math.pi` aufrufen, dazu muss aber auch wieder zuerst das math-Modul importiert werden (`import math`).
+=== 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.
+=== 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$.
+Schreibe eine Funktion `factorial(...)`, der als Argument eine ganze Zahl übergeben wird und die dir dann die Fakultät dieser Zahl zurückgibt.
+**optionale Challenge für absolute Freaks**: Kannst du die Fakultät ganz ohne Schleife berechnen? Dann hast du das Prinzip der *Rekursion* (Selbst-Aufruf) entdeckt!
+=== 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 Liste mit den beiden Werten 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
 <nodisp 1>
-++++Lösung|
-<code python>
-# Variante 1
-def summe_ungerade1(n):
-    i = 1
-    summe = 0
-    while i <= n:
-        summe = summe + i
-        i = i + 2
-    return summe
-# Variante 2
+++++Lösungen Aufgaben F|
-def summe_ungerade2(n):
-    i = 0
-    summe = 0
-    while i <= n:
-        if i % 2 != 0:
-            summe = summe + i
-        i = i + 1
-    return summe
-print(summe_ungerade1(7))
+==== Aufgaben F ====
-print(summe_ungerade2(7))
+=== Aufgabe F1 ===
+<code python>
+def volume_cube(x):
+    return x**3
+v = volume_cube(13)
+print(v)
 </code>
-++++
-</nodisp>
-=== Aufgabe GA5 (Herausforderung) ===
-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$.
+=== Aufgabe F2 ===
-Schreibe eine Funktion //fakultaet//, welcher als Argument eine ganze Zahl übergeben wird und welche dir dann die Fakultät dieser Zahl zurückgibt.
+<code python>
+def pythagoras(a,b):
+    return sqrt(a*a + b*b)
-**Grosse Herausforderung**: Kannst du die Fakultät ganz ohne Schleife berechnen? Dann hast du das Prinzip der *Rekursion* (Selbst-Aufruf) entdeckt!
+print(pythagoras(3,4))
+</code>
-<nodisp 1>
+=== Aufgabe F3 ===
-++++Lösung|
 <code python>
-def fakultaet(n):
+import math
-    result = 1
+def volume_sphere(r):
-    i = 2
+    return 4*math.pi/3 * r**3
-    while i <= n:
-        result = result * i
-        i = i + 1
-    return result
-print(fakultaet(5))
+print(volume_sphere(3))
 </code>
-Rekursiv:
+=== Aufgabe F4 ===
 <code python>
-def fakultaet(n):
+def grade(points,points_6):
-    if n == 1:
+    gr = 5*points/points_6 + 1
-        return 1
+    if gr > 6:
-    return n * fakultaet(n-1)
+        gr = 6.0
+    return round(gr,1)
-print(fakultaet(5))
+print(grade(23,51))
 </code>
-Siehe [[https://youtu.be/DUC1qg7ZaRg|dieses Video]] zur Erklärung
-++++
-</nodisp>
-=== Aufgabe GA6 (optional) ===
-In [[https://sca.ksr.ch/doku.php?id=gf_informatik_1m_20_21:python_zusatzaufgaben#euklidischer_algorithmus|dieser Zusatzaufgabe]] wird der //euklidische Algorithmus// benutzt, um den ggT von zwei Zahlen zu berechnen.
-Schreibe zwei Funktionen //ggt// und //kgv//, welche als Argumente zwei Zahlen nehmen und daraus den grössten gemeinsamen Teiler bzw. das kleinste gemeinsame Vielfache berechnen. Das kGV zweier Zahlen erhältst du, indem du das Produkt dieser Zahlen durch den ggT der beiden Zahlen teilst. Es lohnt sich also, zuerst die Funktion //ggt// zu definieren, damit diese dann in der Definition der Funktion //kgv// aufgerufen werden kann.
-Wenn du das gemacht hast: Erstelle eine weitere Funktion //ggt_kgv//, welche als Argument zusätzlich einen String mit "ggt", bzw. "kgv" entgegennimmt und dann entweder den ggT bzw. das kgV ausgibt.
+=== Aufgabe F5 ===
-<nodisp 2>
-++++Lösung|
 <code python>
+def factorial(n):
+    product = 1
+    i = 1
+    while i <= n:
+         product = product * i
+         i = i + 1
+    return product
-def ggt(a, b):
+print(factorial(5))
-    while b != 0:  # solange Rest nicht 0
+</code>
-        temp = b   # zweite Zahl (b) zwischenspeichern
-        b = a % b  # Rest a / b ermitteln und in b speichern
-        a = temp   # ursprünglicher Wert von b a zuweisen
-    return a
-def kgv(a, b):
-    return a*b/ggt(a,b)
-def ggt_kgv(op, a, b):
+=== Aufgabe F6 ===
-    if op == "ggt":
-        return ggt(a, b)
+<code python>
-    elif op == "kgV":
+def mitternachtsformel(a,b,c):
-        return kgv(a,b)
+    d = b*b - 4*a*c
+    if d < 0:
+        return None
+    elif d == 0:
+        return -b / (2*a)
     else:
-        return "error"
+        r = -b / (2*a)
+        return [(-b - sqrt(d)) / (2*a), (-b + sqrt(d)) / (2*a)]
-print(ggt(391,544))
-print(kgv(4,6))
+print(mitternachtsformel(3,-6,-5)) # 2 Loesungen
-print(ggt_kgv("ggt",12, 18))
+print(mitternachtsformel(1,-4,4))  # 1 Loesung
-print(ggt_kgv("kgV",12, 18))
+print(mitternachtsformel(1,2,7))   # keine Loesung
-print(ggt_kgv("blabla",12, 18))
 </code>
 ++++
-</nodisp>
+</nodisp>