Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

--- gf_informatik:funktionen [2023-02-24 09:17] – [Aufgabe GA5 (Herausforderung)] gra
+++ gf_informatik:funktionen [2025-12-11 10:41] (aktuell) – [Aufgabe F6 (optional)] 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
-    # CODE DER FUNKTION
+    # Codeblock der Funktion
-    return RETURN_WERT # ist 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.
+     * Wie bei Variablen bestimmst du den Namen - er sollte sinnvoll sein und beschreiben, was die Funktion tut.
-   * Nach einem **Doppelpunkt** ...
+   * 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.
-   * kommt der **Funktionskörper**, welcher den eigentlichen Code der Funktion beinhaltet. Dieser Code muss **eingerückt** sein.
+   * 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.
-Ü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.
-In diesem Unterkapitel schauen wir Funktionen ohne Rückgabewert an, also Funktionen ohne das `return`-Statement am Ende.
+<html><script type="module" src="https://bottom.ch/ksr/ed/bottom-editor.js"></script></html>
+<html><bottom-editor>
+def say_hi():
+    print("Hallo du!")
-**Beispiel:** Du möchtest das gleiche Quadrat mehrfach zeichnen. Dies kannst du wie folgt machen:
+say_hi()
+say_hi()
+</bottom-editor></html>
-<code python>
+=== Beispiel 2: Funktion mit Parameter und ohne Rückgabewert ===
-from gturtle import *
-fritz = Turtle()
+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.
-fritz.hideTurtle()
-# Quadrat 1
+Beim ersten Funktionsaufruf unten hat `name` also den Wert `"Silvia"` und beim zweiten den Wert `"Gabriele"`.
-fritz.setPos(-130,0)
-repeat 4:
-    fritz.forward(100)
-    fritz.left(90)
-# Quadrat 2
+<html><bottom-editor>
-fritz.setPos(0,0)
+def say_hi(name):
-repeat 4:
+    print(f"Hallo {name}!")
-    fritz.forward(100)
-    fritz.left(90)
-</code>
-Es fällt auf, das hier zweimal der //identische// Code vorkommt:
+say_hi("Silvia")
-<code python>
+say_hi("Gabriele")
-repeat 4:
+</bottom-editor></html>
-    fritz.forward(100)
-    fritz.left(90)
-</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 3: Funktion ohne Parameter aber mit Rückgabewert ===
-<code python>
+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:
-from gturtle import *
+<html><bottom-editor>
+import random
-fritz = Turtle()
+def wuerfle():
-fritz.hideTurtle()
+    rand_nr = random.randint(1,6)
+    return rand_nr
-def quadrat():
+print(wuerfle())
-    repeat 4:
+print(wuerfle())
-        fritz.forward(100)
+print(wuerfle())
-        fritz.left(90)
+</bottom-editor></html>
-# Quadrat 1
+=== Beispiel 4: Funktion mit Parameter und mit Rückgabewert ===
-fritz.setPos(-130,0)
-quadrat()
-# Quadrat 2
+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:
-fritz.setPos(0,0)
+<html><bottom-editor>
-quadrat()
+import random
-</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:
+def wuerfle(max_nr):
+    rand_nr = random.randint(1,max_nr)
+    return rand_nr
-<code python>
+print(wuerfle(12))
-from gturtle import *
+print(wuerfle(12))
+print(wuerfle(12))
-fritz = Turtle()
+</bottom-editor></html>
-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:
+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>
+<html><bottom-editor>
-from gturtle import *
+import random
-fritz = Turtle()
-fritz.hideTurtle()
-def quadrat(x,y,seite,farbe):
-    fritz.setPos(x,y)
-    fritz.setPenColor(farbe)
-    repeat 4:
-        fritz.forward(seite)
-        fritz.left(90)
-# Quadrat 1
-quadrat(-130,0,70,"red")
-# Quadrat 2
-quadrat(0,0,100,"magenta")
-</code>
-==== Funktionen mit Rückgabewert ====
+def wuerfle(max_nr=6):
+    rand_nr = random.randint(1,max_nr)
+    return rand_nr
-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.
+print(wuerfle(12)) # 12er-Wuerfel
+print(wuerfle())   # 6er-Wuerfel, verwendet Vorgabewert
+</bottom-editor></html>
-**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
+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.
-$$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 ====
+==== Aufgaben E ====
-[[gf_informatik:funktionen:problems|Probleme mit Funktionen]]
-==== Aufgaben G – Funktionen ohne/mit Rückgabewert ====
-=== Aufgabe G1 ===
+**Vorwissen:**
+   * [[gf_informatik:funktionen|Funktionen]]
+   * Bis und mit Beispiel 2 "Funktion mit Parameter und ohne Rückgabewert"
-Für diese Aufgabe benötigst du Turtle graphics.
+Bei diesen Aufgaben geht es um folgendes:
-  - Definiere eine Funktion namens ''spirale()''. Diese zeichnet eine beliebige Spirale aus mindestens 6 Halbkreisen.
+   * Verstehen, was Funktionen sind und wozu sie nützlich sind
-  - 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.
+   * einfache Funktionen programmieren
-=== Aufgabe G2 ===
+=== Aufgabe E1 ===
-  - 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.
+**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!"
-  - Rufe im Code die Funkton ''spirale()'' mindestens drei mal auf, sodass die drei Spiralen an unterschiedlichen Orten gezeichnet werden.
-=== Aufgabe G3 ===
+=== Aufgabe E2 ===
-  - 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.
+Schreibe eine Funktion `head_or_tail()`, die einen Münzenwurf simuliert. Zufällig soll Kopf oder Zahl ausgewählt und ausgegeben werden.
-  - Rufe im Code die Funkton ''spirale()'' mindestens drei mal mit unterschiedlichen Parametern auf.
+<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.
-=== Aufgabe G4 ===
-Für diese Aufgabe benötigst du Turtle graphics. Definiere folgende Funktionen:
+Simuliere nun 20 Münzenwürfe.
-   * quadrat(turtle, seitenlaenge, farbe, x, y)
+++++
-   * dreieck(turtle, seitenlaenge, farbe, x, y)
+</nodisp>
-   * kreis(turtle, radius, farbe, x, y)
-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.
-Zeichne mit diesen Funktionen ein Bild. Jede der drei Formen soll mindestens 3 mal vorkommen. Variiere die Farbe und Grösse der Formen.
+=== Aufgabe E3 ===
-== Erweiterung (Optional) ==
+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.
-Erstelle ein Python Modul:
-  * Speichere die Geometrie-Funktionen in einer separaten Datei `geometrie.py`.
+Rufe die Funktion auf.
-  * 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>
-++++Lösung|
+++++Tipps:|
-<code python geometrie.py>
+Ä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.
-def vieleck(turtle, ecken, seite, farbe, x,y):
+++++
-    turtle.setPos(x,y)
+</nodisp>
-    turtle.setPenColor(farbe)
-    # 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):
+=== Aufgabe E4 ===
-    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):
+TurtleGraphics: Schreibe eine Funktion `square(x)`, die eine Zahl $x$ als Argument entgegen nimmt und ein Quadrat mit dieser Länge zeichnet.
-    turtle.setPos(x,y)
-    turtle.setPenColor(farbe)
-    turtle.leftArc(radius, 360)
-</code>
-<code python kunst.py>
+=== Aufgabe E5 ===
-import geometrie
-from gturtle import *
-t = Turtle()
+Schreibe folgende Funktionen:
-t.hideTurtle()
+   * `square(x,y,l)`: Zeichnet Quadrat mit Seitenlänge l, startend an Position $(x,y)$
+   * `circle(x,y,r)`: Zeichnet Kreis mit Radius r, startend an Position $(x,y)$
+   * `rectange(x,y,a,b)`: Zeichnet Rechteck mit Seitenlängen a und b, startend an Position $(x,y)$
+   * `triangle(x,y,l)`: Zeichnet gleichseitiges Dreieck mit Seitenlänge l, startend an Position $(x,y)$
+   * Funktion für selbst gewählte geometrische Figur
-geometrie.quadrat(t, 100, "red", 0, 0)
+Mache nun moderne Kunst, indem du diese Funktionen aufrufst.
-geometrie.kreis(t, 50, "blue", 0, 50)
-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.
+**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!
-//Tipp:// Die Wurzel einer Zahl ziehst du mit `sqrt(x)`, dazu musst du aber zuerst das math-Modul importieren: `import math`.
+ Vom Zufall abhängen können z.B. folgende Werte:
+   * Anzahl, wie oft jede Funktion aufgerufen wird.
+   * Position von Figuren
+   * Grössen von Figuren
+   * Drehung von Figuren
+   * Farben (Stift- und Füllfarbe), dazu kannst du den Funktionen weitere Argumente übergeben
-//Kontrolle:// Für die Katheten 3 und 4 ist die Hypothenuse 5. Die Codezeile `print(pythagoras(3,4))` soll dann also `5.0` ausgeben.
+Tipps:
+   * 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.
 <nodisp 1>
-++++Lösung|
+++++Lösungen Aufgaben E|
+==== Aufgaben E ====
+=== Aufgabe E1 ===
+<html><bottom-editor>
+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")
+</bottom-editor></html>
+=== Aufgabe E2 ===
+<html><bottom-editor>
+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()
+</bottom-editor></html>
+=== Aufgabe E3 ===
+<html><bottom-editor>
+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()
+</bottom-editor></html>
+=== Aufgabe E4 ===
 <code python>
-import math
+from turtle import *
-def pythagoras(a, b):
+turi = Turtle()
-    return math.sqrt(a**2 + b**2)
+turi.hideturtle()
+turi.speed(1000)
-print(pythagoras(3,4))
+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)
 </code>
-++++
-</nodisp>
-=== Aufgabe G6 ===
-Das Volumen einer Kugel mit Radius $R$ ist: $$V = \frac{4\pi}{3}\cdot R^3$$
+=== Aufgabe E5 ===
-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
+from turtle import *
+t = Turtle()
+t.hideturtle()
-def kugel_volumen(radius):
+def square(x,y,l):
-    return 4 * math.pi / 3 * radius**3
+    t.teleport(x,y)
+    i = 0
+    while i < 4:
+        t.fd(l)
+        t.right(90)
+        i = i + 1
-print kugel_volumen(2)
+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=NobwRAdghgtgpmAXGGUCWEB0AHAnmAGjABMoAXKJMNGbAewCcyACBqCYumAHQgDMGXZmQCuTADZxmNek2YAqXr2Jw-zAM4BHEVAZwAFGQIAPArgLiAlIl7M7wzGTiTZZfadyXb9tMwC8zAAM3nYA7gAWaJLSzAA8zAAsNhD2qQ58xPpWIWlkmAxoAObhbgCcgV4paXa-Ab4A1MwAjEocqswAxmgMHZKGJmYEDNY5eU4ujG4elal5XT19w60qanodFBCFfUYeBFAEAEYjVXZjznCu7mYzPv5BORFRUr7xAEzJ1aeYGfpQN9V5ArFMoVHKzb6ZI5g-yAoolfTlf5pWoxRotCDKdpkArsLYGHaDKwfGGOc6XaY5FHBE7MR7RF7MADMxIBEKySPBQPhTVeoJpqRRDWay3abA4XAA-h06OJGIYxepsLo4BAyH4AGJQcTqODHVJ6Yh3MWcGD5djEDBuJoEZivACsdqRhT0KqN5q4Zo4lv01ttDqRB3EIikAWNHuN3t99sdlLU2PYiuVqpZaS12HCUDd4tNEdV-jtgRt0Y59j0ogYKX0BptzrgKptgeDNrTGaRzh1Kf1cHLlerzFr9eYjd1IrUujIaHUbjIevs6gz2Dg6izJs9FrzCQITT5qTpUnnUEXy4AfEFO3OF0u7gej8wALTC_kXw8h1junPmyM2hIluy46Khu-a7eoWzCItCXySHwbj_iOT52MYK7hp-eZ3k0AAcoEYTuny4EhH5eqh2E2thv4aGgKhNPhwF5ryJGBDhrJ8FE4jSrKDBVu-UoynKAAqDDBpYZF5KEFFkOE-iMbkmAHHAhQYBKzHiOI-hkWgag3iGARNOe1RaDoej9MwpjMOY5GUWRzjqRol7-AE7wQWk8y9PiNomWZ6gUXATSWeI1maXZTK6bkOKbNsbk2h5Xk-Y5VkabZfgBEkjmpJ5KivNRuZuHRzQMWRXbrLBRnuTaaXeaVXmvMJmAqsQiksaprQsAEvFiGQfSVHkkQqOW7UGJ1mCKnWmTbnyvDjpO06VGAAC-AC6QA|Modern Artist]]
 ++++
 </nodisp>
-=== Aufgabe G7 ===
-Definiere eine Funktion //wuerfel//, welche einen Würfel simuliert, d.h. eine Zufallszahl zwischen 1 und 6 mit //return// zurückgibt.
+==== Aufgaben F ====
-{{:gf_informatik:pasted:20230215-091017.png?150|}}
+**Vorwissen:**
+   * [[gf_informatik:funktionen|Funktionen]]
+   * Bis und mit Beispiel 4 "Funktion mit Parameter und Rückgabewert"
-<nodisp 1>
+Bei diesen Aufgaben geht es um folgendes:
-++++Lösung|
-<code python>
-import random
-def wuerfel():
-    return random.randint(1,6)
-print(wuerfel())
+   * Funktionen mit Rückgabewert verstehen und anwenden.
-</code>
+   * Lernen, wann man eine Funktion (k)einen Rückgabewert haben sollte.
-++++
-</nodisp>
-== Challenge (optional) ==
+=== Aufgabe F1 ===
-Simuliere mit TurtleGraphics einen Würfel.
-==== Aufgaben GA – Funktionen mit Algorithmen (ohne/mit Rückgabewert) ====
-=== Aufgabe GA1 – Fibonacci-Zahlen ===
+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.
-Schreibe eine Funkton namens //fibonacci_numbers//, die beliebig viele Elemente der [[https://de.wikipedia.org/wiki/Fibonacci-Folge|Fibonacci-Folge]] ausgibt.
-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.
+Welches Volumen hat ein Würfel mit Seitenlänge 13 cm?
-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.
+=== Aufgabe F2 ===
-<nodisp 1>
+**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.
-++++Lösung|
-<code python>
-def fibonacci_numbers(anz):
-    a = 0
-    b = 1
-    print a
-    print b
-    repeat anz-2:
-        c = a + b
-        print c
-        a = b
-        b = c
-fibonacci_numbers(8)
+//Tipp:// Die Wurzel einer Zahl ziehst du mit `sqrt(x)`, dazu musst du aber zuerst das math-Modul importieren: `import math`.
-</code>
-++++
-</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:**
+//Kontrolle:// Für die Katheten 3 und 4 ist die Hypothenuse 5. Die Codezeile `print(pythagoras(3,4))` soll dann also `5.0` ausgeben.
-  * 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:
-{{:gf_informatik:pasted:20230214-194805.png?200|}}
+=== Aufgabe F3 ===
-<nodisp 1>
+Das Volumen einer Kugel mit Radius $R$ ist: $$V = \frac{4\pi}{3}\cdot R^3$$
-++++Lösung|
+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`).
-<code python>
-from gturtle import *
-leonardo = Turtle()
-def fibonaci_arcs(n):
+=== Aufgabe F4 ===
-    a = b = 1
-    leonardo.leftArc(a*5, 180) # erste zwei Viertelkreise
-    repeat n-2:
-        c = a + b
-        leonardo.leftArc(c*5, 90)
-        a = b
-        b = c
-fibonaci_arcs(9)
+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:
-</code>
+$$\text{Note} = \frac{5 \cdot \text{(erreichte Punkte)}}{\text{Punktzahl für Note 6}} + 1$$
-++++
-</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>
+Beachte:
-import time
+   * 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$.
-time1 = time.time()
+   * Erreicht man mehr Punkte als notwendig für Note 6, soll man trotzdem die Note 6 erhalten.
-## some code that takes some time
-## ...
-time2 = time.time()
-time_passed = time2 - time1
-</code>
-Teste die Funktion zum Beispiel so:
+=== Aufgabe F5 ===
-<code python>
-print(fibonacci_arcs(9))
-</code>
-Damit sollte dein Code das Muster aus neun Viertelkreisen zeichnen und anschliessend die gemessene Anzahl Sekunden ausgeben.
+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$.
-<nodisp 1>
+Schreibe eine Funktion `factorial(...)`, der als Argument eine ganze Zahl übergeben wird und die dir dann die Fakultät dieser Zahl zurückgibt.
-++++Lösung|
-<code python>
-import time
-from gturtle import *
-leonardo = Turtle()
-def fibonaci_arcs(n):
+**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!
-    start_time = time.time()
-    a = b = 1
-    leonardo.leftArc(a*5, 180) # erste zwei Viertelkreise
-    repeat n-2:
-        c = a + b
-        leonardo.leftArc(c*5, 90)
-        a = b
-        b = c
-    return(time.time()-start_time)
-print(fibonaci_arcs(9))
+=== Aufgabe F6 (optional) ===
-</code>
-++++
-</nodisp>
-=== Aufgabe GA4 ===
-Schreibe eine Funktion //summe\_ungerade//, die die Summe aller ungeraden Zahlen von 0 bis n zurückgibt.
+**Mitternachtsformel:** Eine quadratische Funktion kann immer in die Form $$ax^2 + bx + c = 0$$ gebracht werden. Die Lösung ist gegeben durch:
-Zum Beispiel soll ''summe\_ungerade(5)'' die Zahl 9 zurückgeben. Auch ''summe\_ungerade(6)'' soll natürlich 9 zurückgeben.
+$$x = \frac{-b \pm \sqrt{b^2-4ac}}{2a}$$
-//Tipp:// Verwende eine Zählvariable und eine While-Schleife.
+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
 <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))
-</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 F1 ===
-Schreibe eine Funktion //fakultaet//, welcher als Argument eine ganze Zahl übergeben wird und welche dir dann die Fakultät dieser Zahl zurückgibt.
+<html><bottom-editor>
+def volume_cube(x):
+    return x**3
-**Grosse Herausforderung**: Kannst du die Fakultät ganz ohne Schleife berechnen? Dann hast du das Prinzip der *Rekursion* (Selbst-Aufruf) entdeckt!
+v = volume_cube(13)
+print(v)
+</bottom-editor></html>
+=== Aufgabe F2 ===
-<nodisp 2>
+<html><bottom-editor>
-++++Lösung|
+import math
-<code python>
+def pythagoras(a,b):
-def fakultaet(n):
+    return math.sqrt(a*a + b*b)
-    result = 1
-    i = 2
-    while i <= n:
-        result = result * i
-        i = i + 1
-    return result
-print(fakultaet(5))
+print(pythagoras(3,4))
-</code>
+</bottom-editor></html>
-Rekursiv:
-<code python>
-def fakultaet(n):
-    if n == 1:
-        return 1
-    return n * fakultaet(n-1)
-print(fakultaet(5))
+=== Aufgabe F3 ===
-</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.
+<html><bottom-editor>
+import math
+def volume_sphere(r):
+    return 4*math.pi/3 * r**3
-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.
+print(volume_sphere(3))
+</bottom-editor></html>
-<nodisp 1>
-++++Lösung|
-<code python>
-def ggt(a, b):
+=== Aufgabe F4 ===
-    while b != 0:  # solange Rest nicht 0
-        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):
+<html><bottom-editor>
-    return a*b/ggt(a,b)
+def grade(points,points_6):
+    gr = 5*points/points_6 + 1
+    if gr > 6:
+        gr = 6.0
+    return round(gr,1)
-def ggt_kgv(op, a, b):
+print(grade(23,51))
-    if op == "ggt":
+</bottom-editor></html>
-        return ggt(a, b)
-    elif op == "kgV":
-        return kgv(a,b)
+=== Aufgabe F5 ===
+<html><bottom-editor>
+def factorial(n):
+    product = 1
+    i = 1
+    while i <= n:
+         product = product * i
+         i = i + 1
+    return product
+print(factorial(5))
+</bottom-editor></html>
+=== Aufgabe F6 ===
+<html><bottom-editor>
+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:
-        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(ggt_kgv("ggt",12, 18))
-print(ggt_kgv("kgV",12, 18))
-print(ggt_kgv("blabla",12, 18))
-</code>
-++++
-</nodisp>
+print(mitternachtsformel(3,-6,-5)) # 2 Loesungen
+print(mitternachtsformel(1,-4,4))  # 1 Loesung
+print(mitternachtsformel(1,2,7))   # keine Loesung
+</bottom-editor></html>
+++++
+</nodisp>