Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen der Seite angezeigt.

Link zu der Vergleichsansicht

Beide Seiten, vorherige Überarbeitung Vorherige Überarbeitung
Nächste Überarbeitung		 Vorherige Überarbeitung
gf_informatik:programmieren_iv_gra [2025-04-19 10:21] – [Auftrag 3 – Begriffe kennenlernen] gragf_informatik:programmieren_iv_gra [2025-05-09 10:23] (aktuell) – [NC2 – Crimson & Clover] gra
Zeile 5: Zeile 5:
 ++++Lernziele (hidden):| ++++Lernziele (hidden):|
  
-   * tbd+   * Bisheriges plus: 
 +   * Funktionen definieren: Mit/Ohne Arugmente, mit/ohne Rückgabewerte. 
 +   * Begriffe erklären. 
 +   * Logische Operatoren korrekt verwenden.
  
 ++++ ++++
Zeile 11: Zeile 14:
  
 ===== - Einführung ===== ===== - Einführung =====
-Du kennst Variablen – darin kannst du einen Wert speichern. Und du kennst Listen – darin kannst du mehrere Werte speichern. Aber du hast dich villeicht schon gefragt: <color #0433ff>"Was, wenn ich gleich mehrere Codezeilen irgendwo unterbringen will?"</color>. Für diese Idee gibt es **Funktionen**, die wir auch **Unterprogramme** nennen können. Bevor wir anschauen, wie wir Funktionen erstellen und verwenden können, schauen wir uns erst mal ein paar Funktionen an, die du schon oft verwendet hast. +Du kennst Variablen – darin kannst du einen Wert speichern. Und du kennst Listen – darin kannst du mehrere Werte speichern. Aber du hast dich villeicht schon gefragt: <color #0433ff>"Was, wenn ich gleich mehrere Codezeilen irgendwo unterbringen will?"</color>. Für diese Idee gibt es **Funktionen**, die wir auch **Unterprogramme** nennen können.
 === Auftrag 1 – Bereits bekannte Funktionen anschauen === === Auftrag 1 – Bereits bekannte Funktionen anschauen ===
-In Python sind viele Funktionen schon eingebaut. Du hast ein paar davon schon oft verwendet – zun Beispiel:+In Python sind viele Funktionen schon eingebaut. Du hast ein paar davon schon oft verwendet – zum Beispiel ''print'', ''input'' und ''len'':
 <code python> <code python>
 print("Hallo") print("Hallo")
-input("Wie heisst du?") +name = input("Wie heisst du?") 
-len("Apfel")+n_letters = len(name) 
 +print(f"Dein Name hat {n_letters} Buchstaben.")
 </code> </code>
  
-== Aufgabe A == +== Aufgabe == 
-Einzeln: Beantworte folgende Fragen schriftlich. Zu zweit: Vergleicht und ergänzt eure Antworten. +Zu zweit: Besprecht folgende Fragen. Vergleicht dann mit der Lösung unten. 
-  - Was ist allen Funktionen gemeinsam? +  - Was ist allen drei Funktionen gemeinsam? 
-  - Worin unterscheiden sich die Funkionen? +  - Worin unterscheiden sich die Funktionen //strukturell// (abgesehen davon, dass sie unterschiedliche Namen haben und unterschiedliche Zwecke erfüllen)? 
  
-== Aufgabe B == +===== - Theorie =====
-Kopiere obige Codezeilen nach [[https://webtigerpython.ethz.ch/]]. Wenn du den Code ausführst, merkst du, das noch nicht viel passiert. Ergänze den Code wie folgt und **teste nach jedem Schritt**: +
-  - Der Name, den die Benutzer:in eingibt, soll in einer Variable gespeichert werde. +
-  - Statt der Länge des Wortes "Apfel" soll die Länge des eingegebenen Namens ermittelt werden. +
-  - Diese Länge soll in einer Variable gespeichert werden. +
-  - Am Ende soll eine Nachricht in folgendem Format ausgegeben werden: <color #0433ff>"Du heisst Karl, dein Name hat 4 Buchstaben."</color> Verwende einen [[gf_informatik:programmieren_ii_gra#f-strings|f-String]]. +
-Du solltest jetzt ein **vierzeilgies Programm** haben. Jede Zeile enthält eine Funktion.  +
-  * Schaue dir deine Antworten zu Aufgabe A nochmals an und ergänze sie, wenn dir noch mehr auffällt. +
  
-=== Auftag 2 – Eine Funktion (ein Unterprogramm) erstellen und verwenden === +=== Auftrag 2 – Eine Funktion (ein Unterprogramm) erstellen und verwenden === 
-Mit folgendem Code zeichnet die Turlte ein Sechseck (Hexagon):+Mit folgendem Code zeichnet die Turtle einen violeten Punkt, dreht 90 Grad nach rechts und fährt um 40 Pixel weiter:
  
 +<WRAP group>
 +<WRAP column twothirds>
 +<code python>
 +from gturtle import * 
 +karl = Turtle()
 +
 +karl.setPenColor("purple")
 +karl.dot(40)
 +karl.right(90)
 +karl.forward(40)
 +</code>
 +</WRAP>
 +
 +<WRAP column third>
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250423-122049.png?200}}
 +</WRAP>
 +</WRAP>
 +
 +Die letzten vier Codezeilen aus obigem Code packen wir nun in eine Funktion namens "purple_dot". Dann rufen wir die Funktion viermal nacheinander auf:
  
 <WRAP group> <WRAP group>
Zeile 44: Zeile 59:
 from gturtle import *  from gturtle import * 
 karl = Turtle() karl = Turtle()
-side_count = 0 + 
-while side_count < 6: +def purple_dot(): 
-    karl.forward(50) +    karl.setPenColor("purple") 
-    karl.right(60) +    karl.dot(40) 
-    side_count = side_count + 1+    karl.right(90) 
 +    karl.forward(40) 
 + 
 +purple_dot() 
 +purple_dot() 
 +purple_dot() 
 +purple_dot()
 </code> </code>
 </WRAP> </WRAP>
  
 <WRAP column third> <WRAP column third>
-{{:gf_informatik:programmieren_iv_gra:pasted:20250419-095045.png?180}}+{{:gf_informatik:programmieren_iv_gra:pasted:20250423-122800.png?200}}
 </WRAP> </WRAP>
 </WRAP> </WRAP>
  
-Wir möchten jetz **sechs** Sechsecke zeichnen, sodass in der Mitte ein siebtes entsteht ([[https://youtu.be/thOifuHs6eY?si=yKl7z6uLPcnUuNi6|Hexagons are the Bestagons]]). Hierzu erstellen wir erst **eine Funktion namens hexagon()** und rufen sie weiter unten auf:+**Beachte:**  
 +  * Um eine Funktion zu erstellen, benötigst du das Schüsselwort ''def'' (die Funktion wird hier **def**iniert).  
 +  * Dann folgt der Funktionsname mit anschliessenden Klammern und ein Doppelpunkt: 
 +    * alle Codezeilen, die nun eingerückt folgen, gehören zu dieser Funktion. 
 +  * Du musst die Funktion erstellen, **bevor** du sie aufrufst. Die Definition der Funktion erfolgt also immer **oben im Code** und der Aufruf weiter unten. 
 + 
 +== Aufgabe == 
 +<WRAP group> 
 +<WRAP column twothirds> 
 + 
 +Kopiere obigen Code mit der Funktion "purple\_dot" und verändere ihn wie folgt: 
 + 
 +  * Die Funktion soll neu "blue\_dot" heissen. 
 +  * Dein Code soll sechs blaue 20-Pixel-Punkte im Sechseck zeichnen: Siehe Bild: 
 + 
 +</WRAP> 
 + 
 +<WRAP column third> 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250423-130345.png?180}} 
 + 
 +</WRAP> 
 +</WRAP> 
 + 
 +=== Auftrag 3 – Eine Funktion mit Argument erstellen und verwenden === 
 + 
 +Wir können einer Funktion auch ein **Argument** (oder mehrere) mitgeben. Argumente kommen **in die Klammern** rein. In folgendem Beispiel wird als Argument die Farbe übergeben.
  
 <WRAP group> <WRAP group>
Zeile 65: Zeile 111:
 karl = Turtle() karl = Turtle()
  
-# Funktion erstellen mit def funtkionsname():  +def my_dot(color): 
-# Alles darunter Eingerückte gehört zur Funktion+    karl.setPenColor(color) 
 +    karl.dot(40) 
 +    karl.right(90) 
 +    karl.forward(40) 
 + 
 +my_dot("red") 
 +my_dot("blue") 
 +my_dot("orange") 
 +my_dot("green") 
 +</code> 
 +</WRAP> 
 + 
 +<WRAP column third> 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250423-145320.png?200}} 
 +</WRAP> 
 +</WRAP> 
 + 
 +== Aufgabe == 
 +<WRAP group> 
 +<WRAP column twothirds> 
 + 
 +Kopiere obigen Code und verändere ihn wie folgt: 
 + 
 +  * Die Funktion hat ein Argument namens dot_size. Es wird also die Grösse des Punkts mitgegeben. 
 +  * Dein Code zeichnet vier purpurne(("crimson")) Punkte in den Grössen 20, 30, 40, 30, siehe Bild. 
 + 
 +</WRAP> 
 + 
 +<WRAP column third> 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250423-181230.png?200}} 
 + 
 +</WRAP> 
 +</WRAP> 
 +=== Auftrag 4 – Eine Funktion mit Argumenten und Rückgabewert erstellen und verwenden === 
 +Folgende Funktion namens ''schnitt'' berechnet den Durchschnitt zweier Zahlen und gibt das Resultat zurück. Die Funktion wird unten in der Funktion ''print'' aufgerufen.((Der Rückgabewert der Funktion ''schnitt'' wird der Funktion ''print'' als Argument übergeben)). 
 +<code python> 
 +def schnitt(zahl1, zahl2): 
 +    summe = zahl1 + zahl2 
 +    return summe/2 
 + 
 +print(schnitt(4, 5)) 
 +</code> 
 + 
 +**Beachte:** 
 +  * Das Schlüsselwort ''return'' bewirkt Folgendes: 
 +    - Die Funktion wird sofort verlassen. 
 +    - Die Funktion gibt den Wert zurück, der hinter ''return'' steht. 
 +  * Wenn kein Wert hinter return steht, gibt die Funktion ''None'' (nichts) zurück. 
 + 
 + 
 +== Aufgabe == 
 +Erstelle eine Funktion namens ''quader'' mit drei Argumenten namens ''l'', ''b'' und ''h'' für die Länge, Breite und Höhe des Quaders. Die Funktion gibt das Volumen des Quaders zurück. Beispiel: Der Aufruf ''quader(2, 3, 4)'' gibt **24** zurück. Teste die Funktion, indem du sie **dreimal** mit unterschiedlichen Argumenten aufrufst und das Resltat jeweils mit ''print'' ausgibst.  
 + 
 +=== Auftrag 5 – Wichtige Begriffe erklären === 
 +Besprecht zu zweit die folgenden Fragen zu Funktionen. Vergleicht anschliessend mit den Lösungen unten. Lest diese //genau// und fragt bei Bedarf nach! 
 +  - Was ist ein **Argument**? 
 +  - Was ist ein **Rückgabewert**? Welches Schüsselwort ist hier wichtig? 
 +  - Was ist eine **Definition**? Welches Schösselwort ist hierzu nötig? 
 +  - Was ist ein **Aufruf**? 
 + 
 + 
 +===== - Aufgaben N – Funktionen ===== 
 +In folgenden Aufgaben sollst du Funktionen erstellen (= definieren) und verwenden (=aufrufen). 
 + 
 +==== Aufgaben NA – Einfache Funktionen (Unterprogramme) ohne Rückgabewerte ==== 
 +Die folgenden Aufgaben behandeln Funktionen mit und ohne Argumente – aber ohne Rückgabewerte. 
 + 
 +=== NA1 – Blumen === 
 +Schreibe eine Funktion namens ''blume()'', die die Turtle eine Blume wie im Bild unten zeichnen lässt. Rufe die Funktion dreimal auf. Verändere zwischen den Aufrufen die Position der Turtle, soass drei Blumen an unterschiedlichen Orten gezeichnet werden, siehe Bild: 
 + 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250429-194213.png?200}} 
 + 
 +Hinweis: Eine Blume wie im Bild kann aus sechs 30-px-Punkten (''dot'') auf einem Kreis (''righArc'' oder ''leftArc'') mit Radius 20 gezeichnet werden. 
 + 
 +=== NA2 – Bunte Blumen === 
 +Ändere die Funktion ''blume'' aus NA1 so, dass als Argument die Farbe der Blume übergeben werden kann. Rufe die Funktion viermal auf – jedesmal mit anderer Farbe. Verändere zwischen den Aufrufen die Position der Turtle, soass drei Blumen an unterschiedlichen Orten gezeichnet werden, siehe Bild: 
 + 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250430-050227.png?220}} 
 + 
 +=== NA3 – Blumenreihen === 
 +== Schritt 1 == 
 +Ändere die Funktion ''blume'' aus NA2 so, dass neben der Farbe auch die X- und die Y-Position der Blume übergeben werden kann: Also ''blume(color, xpos, ypos)''. Wenn du dann folgenden Code ergänzt, sollten sechs rote Blumen in einer Reihe (wie im Bild unten) gezeichnet werden: 
 +<code python> 
 +x = 0 
 +while x < 600: 
 +    blume("red", x, 0) 
 +    x = x + 100 
 +</code> 
 + 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250430-124125.png?300}} 
 + 
 +== Schritt 2 == 
 +Lösche den vorhin ergänzten Code (die vier Zeilen mit der while-Schleife) und füge stattdessen folgende Codezeilen unterhalb deiner Funktion ''blume'' ein: 
 +<code python> 
 +colors = ["orange", "purple", "blue", "crimson", "pink", "violet"] 
 +xpositions = [0,55,105,145,200,225] 
 +ypositions = [0,25,-10,25,50,10] 
 +</code> 
 + 
 +Schreibe einen möglichst kurzen Code mit while-Schleife, der sechs Blumen anhand der Werte in den drei Listen zeichnet. Es sollte folgendes Bild entstehen: 
 + 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250502-074916.png?200}} 
 + 
 +=== NA4 – Wer hat die schönste Blumenwiese? === 
 + 
 +<WRAP group> 
 +<WRAP column twothirds> 
 +Nutze deine Funktion ''blume'', der du Farbe, X- und Y-Position übergeben kannst. Erstelle ein Bild aus mindestens 20 zufällig angeordneten Blumen mit zufälliger Farbe – zum Beispiel wie das Bild rechts. Beachte folgende Hinweise:  
 +  * Die Hintergrundfarbe kannst du mit der Turtle-Funktion ''clear'' festlegen: z.B. ''flori.clear("gray")''. 
 +  * Die Farbcodes finden sich [[https://trinket.io/docs/colors|hier]]: Übernehme jeweils den ''Turtle name'' **ohne Abstände**. 
 +  * Erstelle eine Liste mit verschiedenen Farbnamen. Daraus wählst du später für jede Blume ein zufälliges Element. 
 +  * Wähle die x-Positionen im Bereich -250 bis 250, und die y-Positionen im Bereich -100 bis 100, sodass ein Bild im Breitformat entsteht. 
 +  * Mit der Funktion ''hideTurtle'' zeichnet deine Turtle sehr schnell. 
 + 
 +</WRAP> 
 + 
 +<WRAP column third> 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250502-083126.png?300}} 
 +</WRAP> 
 +</WRAP> 
 + 
 + 
 + 
 +<color #22b14c>**Wettbewerb: Sende dein schönstes Blumenbild via Teams der LP und nimm an der Wahl zur schönsten Blumenwiese teil!** </color> 
 + 
 + 
 +==== Aufgaben NB – Funktionen (Unterprogramme) mit Rückgabewerten ==== 
 + 
 +=== NB1 – Franken in Kronen === 
 +Schreibe eine Funktion ''chf\_in\_nok'', die Schweizer Franken (CHF) in Norwegische Kronen (NOK) umrechnet. Der Funktion wird eine Zahl in CHF übergeben und sie gibt die richtige Zahl in NOK zurück. Für den Umrechnungsfaktor googelst du einfach nach "chf in nok". 
 +Teste deine Funktion. 
 + 
 +=== NB2 – Maximalwert aus zwei Zahlen === 
 +Schreibe eine Funktion ''max\_von\_zwei(a, b)'', die das grössere der beiden Argumente zurückgibt. Teste deine Funktion für beide Fälle (erstes Argument grösser und zweites Argument grösser). 
 + 
 +=== NB3 – Pfannkuchen === 
 +<WRAP group> 
 +<WRAP column twothirds> 
 +Schreibe eine Funktion ''zutaten\_pfannkuchen(personen)'', die ausgehnd von der Anzahl Personen die Mengen für die Zutaten Mehl, Salz, Milch und Eier berechent und zurückgibt. 
 +Hier die Mengen für eine Person: 
 +  * 50 g Mehl 
 +  * 0.125 Teelöffel Salz 
 +  * 1 dl Milch 
 +  * 1 Ei 
 +**Hinweis:** Hinter ''return'' kannst du mehrere Rückgabewerte anführen: Trenne sie mit Kommas. 
 + 
 +Teste deine Funktion mit folgendem Code: 
 + 
 +</WRAP> 
 +<WRAP column third> 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250507-053931.png?270}} 
 +</WRAP> 
 +</WRAP> 
 + 
 +<code python> 
 +n = input("Wie viele Personen?") 
 +mehl, salz, milch, ei = zutaten_pfannkuchen(n) 
 +print(f"Du brauchst:\n{mehl} g Mehl\n{salz} TL Salz\n{milch} dl Milch\n{ei} Eier") 
 +</code> 
 + 
 +=== NB4 – Minimalwert aus drei Zahlen === 
 + 
 +<box 100% round green|**Logische Verknüpfungen**> 
 + 
 +Mit den Schlüsselworten ''and'' und ''or''kannst du Bedingungen miteinander **verknüpfen**. Mit dem Schlüsselwort ''not'' kannst du Bedingungen und Ausdrücke **invertieren**. Hier drei Beispiele: 
 + 
 +<code python> 
 +a = input("Erste Zahl eingeben:") 
 +b = input("Zweite Zahl eingeben:") 
 + 
 +if a > 0 and b > 0: 
 +    print("Beide Zahlen sind positiv") 
 + 
 +if a > 0 or b > 0: 
 +    print("Mindestens eine der Zahlen ist positiv") 
 + 
 +if not(a > 0 or b > 0): 
 +    print("Keine der Zahlen ist positiv") 
 +</code> 
 + 
 +  * Erste Verzweigung: Eine Verknüpfung mit ''and'' ist wahr, wenn **sowohl** die erste, **als auch** die zweite Bedingung wahr ist. 
 +  * Zweite Verzweigung: Eine Verknüpfung mit ''or'' ist wahr, wenn die erste **oder** die zweite Bedingung **oder** beide wahr sind. 
 +  * Dritte Verzweigung: ''not'' invertiert (negiert) die nachfolgende Bedingung: Wenn das, was nach ''not'' kommt, falsch ist, so ist die gesamte Bedingung wahr – und umgekehrt. 
 + 
 +[[https://webtigerpython.ethz.ch/?code=NobwRAdghgtgpmAXGGUCWEB0AHAnmAGjABMoAXKJMKAAgF4aNsBXMgCgB0wBRAJwGcycGgC0oACwA2NOBgDmcAEZwIiLgEoOERfUYQW7LiIDusoaInTZEBctUatWtADMatAHw0ADG4jEaOp5eahA0YTTYvBiGYABCssTCYlIqNPwY_tgA9ulkaABuDhBOrh7eNFm8ATRBIeERURAxALIZcIIq_DIYwolVyZKpaIIROWh5hWCaxRAuNBBZ7GU-ldVB6nXhkdGcYADS1r1w_ZZDI9m5BUVgAL4AukA|Probiere es aus – teste den Code für alle drei Möglichkeiten!]] 
 + 
 +</box> 
 + 
 +Schreibe eine Funktion ''min\_von\_drei(a, b, c)'', die das kleinste der drei Argumente zurückgibt. Verwende **logische Verknüpfungen** (studiere hierzu die grüne Box oben).  Teste deine Funktion mit folgendem Code: 
 + 
 +<code python> 
 +print(min_von_drei(1,2,3)) 
 +print(min_von_drei(5,6,4)) 
 +print(min_von_drei(9,7,8)) 
 +</code> 
 + 
 +=== NB5 – Maximalwert aus Liste === 
 +Schreibe eine Funktion ''max\_in\_liste(liste)'', die das grösste Element aus einer Liste zurückgibt. Verwende eine Schleife. Verwende keine bestehende Funktion. Teste deine Funktion mit folgenden drei Listen: 
 + 
 +<code python> 
 +list1 = [11, 16, 5, 12, 3, 13]  
 +list2 = [13, 2, 5, 10, 1, 17, 5, 25] 
 +list3 = [-25, -13, -3, -33] 
 +</code> 
 + 
 +=== NB6 – Gerade oder ungerade === 
 +Schreibe eine Funktion ''ist\_gerade(n)'', die ''True'' zurückgibt, wenn n gerade ist, sonst ''False''. Teste deine Funktion mit folgendem Code: 
 + 
 +<code python> 
 +zahl = input("Bitte ganze Zahl eingeben:") 
 + 
 +if ist_gerade(zahl): 
 +    print("Die Zahl ist gerade") 
 +else: 
 +    print("Die Zahl ist ungerade") 
 +</code> 
 + 
 +**Frage:** Bisher hatten wir in einer if-Verzeigung immer eine Bedingung mit Vergleichsoperatoren stehen. Zum Beispiel //x > 4// oder //x % 2 == 0// etc. In diesem Code steht bloss die Funktion ist_gerade(). Wie erklärst du, dass hier keine Bedingung nötig ist? Bespreche deine Antwort mit der Lehrperson. 
 + 
 +=== NB7 – Pizzabestellung === 
 + 
 +<WRAP group> 
 +<WRAP column twothirds> 
 + 
 +Schreibe eine Funktion ''pizza\_lieferung(personen)'', die ausgehend von der Anzahl Personen den Preis für die Pizzalieferung berechnet und zurückgibt: Jede Pizza kostet 12 Franken. Die Liefergebühren betragen 20 Franken. Ab einem Bestellwert von 50 Franken entfallen die Liefergebühren. Teste deine Funktion. 
 + 
 +</WRAP> 
 +<WRAP column third> 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250507-061750.png?200}} 
 +</WRAP> 
 +</WRAP> 
 + 
 +**Frage:** Wenn ihr zu viert seid: Bestellt ihr besser 4 oder 5 Pizzas? 
 + 
 +=== NA8 – Nächte im Hotel === 
 + 
 +<WRAP group> 
 +<WRAP column twothirds> 
 +Schreibe eine Funktion ''hotel\_preise(personen, naechte, klasse)'', die den Gesamtpreis für einen Hotelaufenthalt gemäss folgender Tabelle berechnet und zurückgibt: 
 +Preise **pro Nacht**: 
 +^ Klasse    ^ Einzelzimmer  ^ Doppelzimmer  ^ 
 +| Standard  | 120           | 160           | 
 +| Ausblick  | 140           | 180           | 
 +| Balkon    | 200           | 260           | 
 + 
 +**Hinweise:**  
 +  * Deine Funktion muss zuerst die Anzahl Einzel- und Doppelzimmer berechnen (ausgehend von der Anzahl Personen): Es ist maximal ein Einzelzimmer nötig. 
 +  * Falls für die Klasse etwas anderes als "Standard", "Ausblick" oder "Balkon" angegeben wird, wird der höchste Preis (Balkon) berechnet. 
 + 
 +</WRAP> 
 +<WRAP column third> 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250507-120048.png?270}} 
 +</WRAP> 
 +</WRAP> 
 + 
 +Teste deine Funktion mit folgendem Code: 
 +<code python> 
 +# Reise 1: 2 Personen, 2 Nächte, Standard: Preis = 320 
 +print(hotel_preise(2, 2, "Standard")) 
 +# Reise 2: 5 Personen, 3 Nächte, Ausblick: Preis = 1500 
 +print(hotel_preise(5, 3, "Ausblick")) 
 +# Reise 3: 6 Personen, 4 Nächte, Balkon: Preis = 3120 
 +print(hotel_preise(6, 4, "Balkon")) 
 +# Reise 4: 1 Person, 1 Nacht, falsche Angabe: Preis = 200 
 +print(hotel_preise(1, 1, "stanDart")) 
 +</code> 
 + 
 + 
 +==== Aufgaben NC – Funktionen mit und ohne Rückgabewerte ==== 
 +=== NC1 – Hexagons are the Bestagons === 
 +  - Schreibe eine Funktion ''hexagon()'', die deine Turtle ein Sechseck zeichnen lässt.  
 +  - Verwende anschliessend  diese Funktion in einer while-Schleife, um sechs Sechsecke zu zeichnen, sodass in der Mitte ein siebtes entsteht (Siehe Bild). 
 + 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250419-100942.png?300}} 
 + 
 +Wenn du das geschafft hast, darfst du folgendes Video schauen: [[https://youtu.be/thOifuHs6eY?si=yKl7z6uLPcnUuNi6|Hexagons are the Bestagons]]. 
 + 
 +=== NC2 – Crimson & Clover === 
 +Crimson & Clover ist der Titel [[https://youtu.be/-wXJ1WN3GR4?si=ngF7kK59Rw1MqoYx|dieses Liedes]] von Tommy James and the Shondells. 
 + 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250508-195423.png?300}} {{:gf_informatik:programmieren_iv_gra:pasted:20250508-195521.png?210}} 
 + 
 + 
 +== Schritt 1 – Herzblatt == 
 +<WRAP group> 
 +<WRAP column half> 
 +Schreibe eine Funktion ''herzblatt(seite, farbe)'', die ein farbiges Herzblatt gemäss der Zeichnung rechts malt:  
 +  * Das Argument ''seite'' bestimmt die Seitenlänge des Quadrats im Herzblatt. 
 +  * Das Argument ''farbe'' bestimmt die Farbe des Herzblatts.  
 +  * Verwende die Turtle-Funktionen ''setFillColor(color)'', ''startPath()'' und ''fillPath()''.  
 +  * Teste die Funktion. 
 + 
 +</WRAP> 
 +<WRAP column quater> 
 + 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250508-100926.png?150}} 
 + 
 +</WRAP> 
 +<WRAP column quater> 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250509-060712.png?150}} 
 + 
 +</WRAP> 
 +</WRAP> 
 + 
 +== Schritt 2 – Kleeblätter == 
 +<WRAP group> 
 +<WRAP column half> 
 +Schreibe eine weitere Funktionen ''kleeblatt3(radius)'', die ein <color #008000>grünes</color>, dreiblättriges Kleeblatt malt. 
 +  * Verwende die eben erstellte Funktion herzblatt. 
 +  * Das Argument ''radius'' bestimmt den (inneren) Radius, du kannst es einfach an die Funktion ''herzblatt'' weitergeben. 
 +  * Teste die Funktion. 
 + 
 +Wiederhole Schritt 2 für eine Funktion ''kleeblatt4(radius)'', die ein <color #006400>dunkelgrünes</color>, vierblättriges Kleeblatt malt. 
 + 
 +</WRAP> 
 +<WRAP column quater> 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250508-200449.png?150}} 
 +</WRAP> 
 +<WRAP column quater> 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250509-060512.png?150}} 
 +</WRAP> 
 +</WRAP> 
 + 
 +== Schritt 3 – Crimson & Clover == 
 +<WRAP group> 
 +<WRAP column half> 
 +Schreibe ein Programm, das die Kleeblatt-Funktionen verwendet und eine zufällige Wiese aus ingesamt 30 Purpur-Punkten und Kleeblättern malt, ähnlich dem Bild rechts:  
 +  * Jede siebte Figur ist ein vierblättriges Kleeblatt. 
 +  * Jede dritte Figur ist dreiblättriges Kleeblatt. 
 +  * Alle anderen Figuren sind Purpur-Punkte. 
 +  * Die Grösse jedes Kleeblatts oder Punktes wird jeweils zufällig bestimmt. 
 +  * Beachte die Hinweise in Aufgabe NA4. 
 +</WRAP> 
 + 
 +<WRAP column half> 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250509-060413.png?300}} 
 +</WRAP> 
 +</WRAP> 
 + 
 +== Zusatzaufgabe == 
 +<WRAP group> 
 +<WRAP column half> 
 + 
 +Verbessere deine Herzblatt-Funktion: ''herzblatt2(seite, farbe1, farbe2)'' soll ein //zweifarbiges// Herzblatt zeichnen. Wie im nebenstehenden Bild.  
 +  * Um ein Herz auf diese Weise zu zeichnen, benötigst du die Funktion ''sqrt()'', die die Quadratwurzel (square root) aus einer Zahl ermittelt. Hierzu musst du das Modul ''math'' importieren: 
 +<code python> 
 +import math 
 +print(math.sqrt(4)) 
 +</code> 
 +</WRAP> 
 + 
 +<WRAP column half> 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250509-101538.png?250}} 
 +</WRAP> 
 +</WRAP> 
 + 
 +===== - Aufgaben O – Funktionen für Fortgeschrittene ===== 
 +=== O1 – Weitere Nächte im Hotel === 
 + 
 +<WRAP group> 
 +<WRAP column twothirds> 
 +Schreibe eine neue Funktion ''hotel\_preise2(personen, naechte, anreisetag)'', die den Gesamtpreis für einen Hotelaufenthalt berechnet und zurückgibt: 
 +Preise **pro Nacht**: 
 +^ Tarif (Anreisetag)      ^ Einzelzimmer  ^ Doppelzimmer  ^ 
 +| Sonntag bis Donnerstag  | 120           | 140           | 
 +| Freitag und Samstag     | 150           | 200           | 
 + 
 +</WRAP> 
 +<WRAP column third> 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250508-071652.png?220}} 
 +</WRAP> 
 +</WRAP> 
 +**Hinweise:**  
 +  * Deine Funktion muss zuerst die Anzahl Einzel- und Doppelzimmer berechnen (ausgehend von der Anzahl Personen): Es ist maximal ein Einzelzimmer nötig. 
 +  * Die Angabe des Anreisetags erfolgt als Text, z. B. "Freitag", siehe Code unten. 
 +  * Erstelle in der Funktion eine Liste ''tage'' mit Texten für jeden Wochentag. Mit der Funktion ''index'' kannst du die Position eines gegebenen Wochentags ermitteln, z.B. gäbe ''tage.index("Dienstag")'' den Wert **1** zurück. 
 +  * Wenn du die Position des Anreisetag weisst, kannst du für jede Nacht beurteilen, ob Wochenendtarif gilt oder nicht – aber wie? Versuche es erst ohne Hilfe von KI.  
 + 
 +Teste deine Funktion mit folgendem Code: 
 +<code python> 
 +# Reise 1: 2 Personen, 2 Nächte ab Freitag: Preis = 400 
 +print(hotel_preise2(2, 2, "Freitag")) 
 +# Reise 2: 3 Personen, 4 Nächte ab Mittwoch: Preis = 1220  
 +print(hotel_preise2(3, 4, "Mittwoch")) 
 +# Reise 3: 1 Person, 10 Nächte ab Donnerstag: Preis = 1320 
 +print(hotel_preise2(1, 10, "Donnerstag")) 
 +</code> 
 + 
 +=== O2 – RGB-Palette === 
 +  - Schreibe eine Funktion ''rgb\_dot(red, green, blue)'', die einen Punkt in der gewünschten Farbe zeigt.  
 +    * Die drei Argumente können jeweils einen Wert zwischen 0 und 5 einnehmen:  
 +    * ''rgb\_dot(0,0,0)'' soll einen schwarzen Punkt zeichnen,  
 +    * ''rgb\_dot(5,0,0)'' einen ganz roten Punkt und  
 +    * ''rgb\_dot(5,5,5)'' einen weissen Punkt. 
 +  - Ergänze einen Code, der alle 216 Farben, die mit dieser Funktion gezeichnet werden können, in einer Farbpallete wie im Bild unten aufzeichnet. 
 +{{:gf_informatik:programmieren_iv_gra:pasted:20250508-075047.png}} 
 +  * In jedem der sechs Quadrate nimmt der Blau-Anteil jeweils von links nach rechts und der Grün-Anteil von oben nach unten zu.  
 +  * Über die sechs Quadrate hinweg nimmt der Rot-Anteil von links nach rechts zu. 
 + 
 + 
 + 
 + 
 +===== - Lösungen ===== 
 + 
 +**Achtung:** Meist gibt es mehrere Lösungen. Nur weil deine Lösung anders ist als diejenige in den Musterlösungen unten, bedeutet dies nicht, dass deine nicht richtig/gut ist. Sende oder zeige im Zweifelsfall deine Lösung der Lehrperson. 
 + 
 +<nodisp 1> 
 + 
 +++++Lösungen zu den Aufträgen (Einstieg und Theorie)| 
 + 
 +=== Auftrag 1 === 
 +  - Alle Funktionen haben Klammern. 
 +  - Die Funktionen ''input'' und ''len'' geben einen Wert zurück, den wir im Code verwenden wollen und deshalb in einer Variable speichern. Von ''print'' erwarten wir üblicherweise keinen Rückgabewert. 
 + 
 +=== Auftrag 2 === 
 +<WRAP group> 
 +<WRAP column half> 
 +Variante 1 
 +<code python> 
 +from gturtle import *  
 +karl = Turtle() 
 + 
 +def blue_dot(): 
 +    karl.setPenColor("blue") 
 +    karl.dot(20) 
 +    karl.right(60) 
 +    karl.forward(20) 
 + 
 +blue_dot() 
 +blue_dot() 
 +blue_dot() 
 +blue_dot() 
 +blue_dot() 
 +blue_dot() 
 +</code> 
 +</WRAP> 
 + 
 +<WRAP column half> 
 +Variante 2 
 + 
 +<code python> 
 +from gturtle import *  
 +karl = Turtle() 
 + 
 +def blue_dot(): 
 +    karl.setPenColor("blue") 
 +    karl.dot(20) 
 +    karl.right(60) 
 +    karl.forward(20) 
 + 
 +count = 0 
 +while count < 6: 
 +    blue_dot() 
 +    count = count + 1 
 +</code> 
 +</WRAP> 
 +</WRAP> 
 + 
 +=== Auftrag 3 === 
 + 
 +<code python> 
 +from gturtle import *  
 +karl = Turtle() 
 + 
 +def my_dot(dot_size): 
 +    karl.setPenColor("crimson") 
 +    karl.dot(dot_size) 
 +    karl.right(90) 
 +    karl.forward(40) 
 + 
 +my_dot(20) 
 +my_dot(30) 
 +my_dot(40) 
 +my_dot(30) 
 +</code> 
 + 
 +=== Auftrag 4 === 
 + 
 +<code python> 
 +# Funktion erstellen: 
 +def quader(l, b, h): 
 +    return l * b * h 
 + 
 +#Funktion dreimal aufrufen und Resultat ausgeben: 
 +print(quader(2,3,4)) 
 +print(quader(3,3,3)) 
 +print(quader(4,5,5)) 
 +</code> 
 + 
 +=== Auftrag 5 === 
 + 
 +  - Ein **Argument** ist das, was der Funktion //übergeben// oder //mitgegeben// wird. Es wird in die **Klammern** der Funktion geschrieben. Eine Funktion kann eines, mehrere oder gar kein Arugment haben. Wenn sie kein Argument hat, bleiben die Klammern leer. Als Argumente können Zahlen, Texte, Variablen oder Listen übergeben werden. 
 +  - Ein **Rückgabewert** ist das, was die Funktion //zurückgibt//. Eine Funktion kann einen, mehrere oder gar keinen Rückgabewert haben. In der Defintion der Funktion schreibst du den Rückgabewert hinter das Schlüsselwort ''return''. Wenn du die Funktion aufrufst, steht der Rückgabewert dort, wo die Funktion steht. Ist dir das klar? Falls nicht: Lehrperson fragen! 
 +  - In der **Defintion** erstellst du die Funktion. Hierzu benötigst du das Schlüsselwort ''def'', gefolgt vom Funktionsnamen, runden Klammern und einem Doppelpunkt. In den folgenden eingerückten Zeilen //definierst// du den Code, der ausgeführt wird, wenn die Funktion aufgerufen wird. 
 +  - Im **Aufruf** rufst du die Funktion auf. Eine bereits definierte oder bekannte Funktion kannst du beliebig oft aufrufen. 
 + 
 +++++ 
 +</nodisp> 
 + 
 +<nodisp 2> 
 +++++Lösungen zu Aufgaben NA:| 
 +=== NA1 === 
 +<code python> 
 +from gturtle import * 
 +flori = Turtle() 
 + 
 +def blume(): 
 +    flori.setPenColor("crimson") 
 +    i = 0 
 +    while i < 6: 
 +        flori.rightArc(20, 60) 
 +        flori.dot(30) 
 +        i = i + 1 
 + 
 +blume() 
 +flori.setPos(60,60) 
 +blume() 
 +flori.setPos(100,-20) 
 +blume() 
 +</code> 
 + 
 +=== NA2 === 
 +<code python> 
 +from gturtle import * 
 +flori = Turtle() 
 + 
 +def blume(color): 
 +    flori.setPenColor(color) 
 +    i = 0 
 +    while i < 6: 
 +        flori.rightArc(20, 60) 
 +        flori.dot(30) 
 +        i = i + 1 
 + 
 +blume("blue") 
 +flori.setPos(60,60) 
 +blume("violet") 
 +flori.setPos(80,-20) 
 +blume("orange") 
 +flori.setPos(140, 30) 
 +blume("purple") 
 +</code> 
 + 
 +=== NA3 – Schritt 1 === 
 +<code python> 
 +from gturtle import * 
 +flori = Turtle() 
 + 
 +def blume(color, xpos, ypos): 
 +    flori.setPenColor(color) 
 +    flori.setPos(xpos, ypos) 
 +    i = 0 
 +    while i < 6: 
 +        flori.rightArc(20, 60) 
 +        flori.dot(30) 
 +        i = i + 1 
 +x = 0 
 +while x < 600: 
 +    blume("red", x, 0) 
 +    x = x + 100 
 +</code> 
 + 
 +=== NA3 – Schritt 2 === 
 +<code python> 
 +from gturtle import * 
 +flori = Turtle() 
 + 
 +def blume(color, xpos, ypos): 
 +    flori.setPenColor(color) 
 +    flori.setPos(xpos, ypos) 
 +    i = 0 
 +    while i < 6: 
 +        flori.rightArc(20, 60) 
 +        flori.dot(30) 
 +        i = i + 1 
 + 
 +colors = ["orange", "purple", "blue", "crimson", "pink", "violet", "yellow"] 
 +xpositions = [0,55,105,145,200,225] 
 +ypositions = [0,25,-10,25,50,10] 
 + 
 +i = 0 
 +while i < 6: 
 +    blume(colors[i], xpositions[i], ypositions[i]) 
 +    i = i + 1 
 +</code> 
 + 
 +=== NA4 === 
 +<code python> 
 +from gturtle import * 
 +flori = Turtle() 
 +flori.hideTurtle() 
 +flori.clear("seagreen") 
 + 
 +def blume(color, xpos, ypos): 
 +    flori.setPenColor(color) 
 +    flori.setPos(xpos, ypos) 
 +    i = 0 
 +    while i < 6: 
 +        flori.rightArc(20, 60) 
 +        flori.dot(30) 
 +        i = i + 1 
 + 
 +colors = ["orange", "purple", "pink", "crimson", "indigo", "violet", "magenta", "deeppink", "gold", "lightcoral"] 
 + 
 +i = 0 
 +while i < 20: 
 +    col_pos = random.randint(0,9) 
 +    blume(colors[col_pos], random.randint(-250,250), random.randint(-100,100)) 
 +    i = i + 1 
 +</code> 
 +++++ 
 + 
 +++++Lösungen zu Aufgaben NB:| 
 +=== NB1 === 
 +<code python> 
 +def chf_in_nok(chf): 
 +    return chf * 12.57 
 + 
 +print(chf_in_nok(3)) 
 +</code> 
 + 
 +=== NB2 === 
 +<code python> 
 +def max_von_zwei(a, b): 
 +    if a > b: 
 +        return a 
 +    else: 
 +        return b 
 + 
 +print(max_von_zwei(2,3)) 
 +print(max_von_zwei(3,4)) 
 +</code> 
 + 
 +=== NB3 === 
 +<code python> 
 +def zutaten_pfannkuchen(n): 
 +    return n * 50, n * 0.125, n, n 
 + 
 +n = input("Wie viele Personen?") 
 +mehl, salz, milch, ei = zutaten_pfannkuchen(n) 
 +print(f"Du brauchst:\n{mehl} g Mehl\n{salz} TL Salz\n{milch} dl Milch\n{ei} Eier") 
 +</code> 
 + 
 +=== NB4 === 
 +<code python> 
 +def min_von_drei(a, b, c): 
 +    if a < b and a < c: 
 +        return a 
 +    elif b < a and b < c: 
 +        return b 
 +    else: 
 +        return c 
 + 
 +print(min_von_drei(1,2,3)) 
 +print(min_von_drei(5,6,4)) 
 +print(min_von_drei(9,7,8)) 
 +</code> 
 + 
 +=== NB5 === 
 +<code python> 
 +list1 = [11, 16, 5, 12, 3, 13]  
 +list2 = [13, 2, 5, 10, 1, 17, 5, 25] 
 +list3 = [-25, -13, -3, -33] 
 + 
 +def max_in_liste(liste): 
 +    max_wert = liste[0] 
 +    i = 1 
 +    while i < len(liste): 
 +        if liste[i] > max_wert: 
 +            max_wert = liste[i] 
 +        i = i + 1 
 +    return max_wert 
 + 
 +print(max_in_liste(list1)) 
 +print(max_in_liste(list2)) 
 +print(max_in_liste(list3)) 
 +</code> 
 + 
 +=== NB6 === 
 +<code python> 
 +def ist_gerade(n): 
 +    if n % 2 == 0: 
 +        return True 
 +    return False 
 + 
 +print(ist_gerade(4)) 
 +print(ist_gerade(5)) 
 +</code> 
 + 
 +=== NB7 === 
 +<code python> 
 +def pizza_lieferung(personen): 
 +    if personen * 12 >= 50: 
 +        return personen * 12 
 +    else: 
 +        return personen * 12 + 20 
 + 
 +print(pizza_lieferung(4)) 
 +print(pizza_lieferung(5)) 
 +</code> 
 + 
 +=== NB8 === 
 +<code python> 
 + 
 +</code> 
 +++++ 
 + 
 +++++Lösungen zu Aufgaben NC:| 
 + 
 +=== NC1 === 
 +<code python> 
 +from gturtle import* 
 +karl = Turtle() 
 def hexagon():  def hexagon(): 
     side_count = 0     side_count = 0
Zeile 76: Zeile 835:
 hex_count = 0  hex_count = 0 
 while hex_count < 6: while hex_count < 6:
-    hexagon() # Funktion aufrufen+    hexagon()
     karl.forward(50)     karl.forward(50)
     karl.left(60)     karl.left(60)
     hex_count = hex_count + 1     hex_count = hex_count + 1
 </code> </code>
-</WRAP> 
  
-<WRAP column third> +=== NC2 === 
-{{:gf_informatik:programmieren_iv_gra:pasted:20250419-100942.png?300}}</WRAP> +<code python> 
-</WRAP> +import random 
-=== Auftrag 3 – Begriffe kennenlernen === +from gturtle import * 
-Argument, Rückgabewert, Definition, Aufruf. +tommy = Turtle() 
 +tommy.hideTurtle() 
 +tommy.clear("goldenrod")
  
 +def herzblatt(seite, farbe):
 +    tommy.setFillColor(farbe)
 +    tommy.startPath()
 +    tommy.forward(seite)
 +    tommy.rightArc(seite/2,180)
 +    tommy.left(90)
 +    tommy.rightArc(seite/2,180)
 +    tommy.forward(seite)
 +    tommy.fillPath()
 +    tommy.right(90)
  
-===== - Aufgaben N =====+def kleeblatt3(radius): 
 +    i = 0 
 +    while i < 3: 
 +        herzblatt(radius, "green") 
 +        tommy.right(120) 
 +        i = i + 1
  
-===== - Lösungen =====+def kleeblatt4(radius): 
 +    i = 0 
 +    while i < 4: 
 +        herzblatt(radius, "darkgreen") 
 +        tommy.right(90) 
 +        i = i + 1 
 +         
 +i = 1  
 +while i < 30: 
 +    xpos = random.randint(-250,250) 
 +    ypos = random.randint(-100, 100) 
 +    size = random.randint(20,30) 
 +    tommy.setPos(xpos, ypos)
  
 +    if i % 7 == 0: 
 +        kleeblatt4(size)
 +    elif i % 3 == 0:
 +        kleeblatt3(size)
 +    else:
 +        tommy.setPenColor("crimson")
 +        tommy.dot(size)
 +        
 +    i = i + 1
 +</code>
  
 +=== NC3 ===
 +<code python>
  
 +</code>
  
 +=== NC4 ===
 +<code python>
 +
 +</code>
 +++++
 +
 +++++Lösungen zu Aufgaben O:|
 +
 +=== O1 ===
 +<code python>
 +def hotel_preise2(personen, naechte, anreisetag):
 +    doppelzimmer = personen // 2
 +    einzelzimmer = personen % 2
 +    tage = ["Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"]    
 +    starttag = tage.index(anreisetag)
 +    preis = 0
 +    nacht = 0
 +    
 +    while nacht < naechte:
 +        aktueller_tag_index = (starttag + nacht) % 7
 +        aktueller_tag = tage[aktueller_tag_index]
 +        
 +        if aktueller_tag in ["Freitag", "Samstag"]:
 +            preis = preis + doppelzimmer * 200 + einzelzimmer * 150
 +        else:
 +            preis = preis + doppelzimmer * 140 + einzelzimmer * 120
 +            
 +        nacht = nacht + 1
 +        
 +    return preis
 +
 +# Reise 1: 2 Personen, 2 Nächte ab Freitag: Preis = 400
 +print(hotel_preise2(2, 2, "Freitag"))
 +# Reise 2: 3 Personen, 4 Nächte ab Mittwoch: Preis = 1220 
 +print(hotel_preise2(3, 4, "Mittwoch"))
 +# Reise 3: 1 Person, 10 Nächte ab Donnerstag: Preis = 1320
 +print(hotel_preise2(1, 10, "Donnerstag"))
 +</code>
 +
 +=== O2 ===
 +<code python>
 +from gturtle import *
 +paula = Turtle()
 +
 +def rgb_dot(red, green, blue):
 +    hexcodes = ["00", "33", "66", "99", "CC", "FF"]
 +    colorcode = hexcodes[red] + hexcodes[green] + hexcodes[blue]
 +    paula.setPenColor(colorcode)
 +    paula.dot(40)
 +    
 +paula.right(90)
 +xpos = 0
 +ypos = 0
 +
 +for r in range(6):
 +
 +    for g in range(6):
 +    
 +        for b in range(6):
 +            paula.setPos(xpos, ypos)
 +            rgb_dot(r,g,b)
 +            xpos = xpos + 50
 +            
 +        xpos = xpos - 300
 +        ypos = ypos - 50
 +        
 +    xpos = xpos + 350
 +    ypos = 0
 +</code>
 +
 +=== O3 ===
 +<code python>
 +
 +</code>
 +
 +=== O4 ===
 +<code python>
 +
 +</code>
 +++++
 +</nodisp>
  • gf_informatik/programmieren_iv_gra.1745058097.txt.gz
  • Zuletzt geändert: 2025-04-19 10:21
  • von gra