lehrkraefte:snr:informatik:bruehl-2022:funktionen-ausfuehrliche-version [https://fginfo.ksbg.ch Fachgruppe Informatik der KSBG]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
~~NOTOC~~

====== Funktionen ======

Besprechung der Hausaufgaben

===== Lernziele heute =====

  * Funktionen oder: Wie man grössere Programm übersichtlich gestaltet: modularer Entwurf, Baukastenprinzip.
  * Nebenbei: Rechnen mit Strings (= Zeichenketten)
===== Aufgabe 1 =====

<WRAP center round todo 100%>
**Gemeinsam an Tafel**

Wenn man ein Haus baut, welche Arbeiten müssen durchgeführt werden? Reihenfolge egal, denkt an die beteiligten Handwerker. 

<hidden Was zeichnet "Gesellschaften" von Menschen oder Tieren aus, die besonders "erfolgreich" sind?>

Arbeitsteilung, hoher Spezialisierungsgrad. Zum Beispiel gibt es laut [[https://de.wikipedia.org/wiki/Arbeitsteilung|Wikipedia: Arbeitsteilung]]
aktuell in Deutschland etwa 24'000 Berufe! Die "Höhlenmenschen" hatten viel weniger "Berufe".
</hidden>
</WRAP>

===== Allgemeines zu Funktionen =====

<WRAP center round info 100%>
Das Aufteilen einer grösseren Vorhabens in Teilvorhaben, die sogenannten **Module**, nennt man **Modularisierung**, auch **modularen Entwurf** oder **Baukastenprinzip**.

In der Informatik wird dies oft durch **Funktionen** bewerkstelligt. "Funktionen sind die Spezialisten beim Programmieren."

Wir haben schon viele Funktionen kennengelernt und verwendet, z. B. ''print'', ''input'', ''forward'', ''right'', ''penUp'', ''makeTurtle'', ''setPenColor'', ''random''.

Funktionen werden aufgerufen (**Funktionsaufruf**), indem man den jeweiligen Funktionsnamen angibt und danach in runden Klammern geeignete **Parameter** (= Übergabewerte) angibt. 

**Die runden Klammern sind beim Funktionsaufreu stets hinzuschreiben, auch wenn keine Parameter übergeben werden.** 

Beispiele:
  * ''setPenColor("red")'' ist ein Aufruf der Funktion ''setPenColor'' mit ''"red"'' als Parameter.
  * ''penUp()'' ist ein Aufruf der Funktion ''penUp''; diese Funktion nimmt keine Parameter entgegen.

Zum besseren Verständnis ist es sinnvoll, Funktionen in vier Arten einzuteilen, je nachdem, ob sie
  * **Parameter** (= Übergabewerte) benötigen oder nicht;
  * einen **Rückgabewert** zurückgeben oder nicht.

In der folgenden Tabelle ist für jeder dieser vier Arten ein Beispiel angegeben und darunter ein Aufruf der Funktion.
<WRAP round box 60%>
|Funktionen ^ ohne Parameter ^ mit Parameter(n) ^
^ ohne Rückgabewert | ''makeTurtle'' | ''penWidth'' |
^ | ''makeTurtle()'' | ''penWidth(10)'' |
^ mit Rückgabewert | ''random'' | ''input'' |
^ | ''random()'' | ''input("Wie heisst du?")'' |
</WRAP>
</WRAP>

<WRAP center round important 100%>
Grob gesagt kann man Aufrufe (und Definitionen, siehe unten) von Funktionen daran erkennen, dass nach ihnen ein Paar runder Klammern (mit oder ohne Parameter dazwischen) auftaucht!

Beachte: Sogenannte **Schlüsselworte** wie ''repeat'', ''if'', ''else'', ''while'' etc. sind keine Funktionen. Sie werden verwendet, um den Ablauf von Python-Programmen zu steuern.

Die Zusatzinformation, die sie entgegennehmen (etwa die ''13'' in ''repeat 13:'' oder die Bedingung ''x == 2'' in ''if x == 2:'') wird bei gutem Programmierstil **NICHT** in runde Klammern eingeschlossen.

Also bitte nicht ''repeat(13):'' oder ''if(x==2):'' schreiben (auch wenn es keine Fehlermeldung gibt).
</WRAP>

<WRAP center round box 100%>
In den folgenden Aufgaben lernst du durch Beispiele, wie du selbst neue Funktionen definieren kannst.

Die folgende Tabelle stellt dar, welche Aufgabe sich mit welcher Art von Funktion beschäftigt und welche Funktionen darin definiert werden.
<WRAP round box 60%>
|Funktionen ^ ohne Parameter ^ mit einem Parameter ^
^ ohne Rückgabewert | [[lehrkraefte:snr:informatik:bruehl-2022:funktionen#aufgabe_2_funktionen_ohne_parameter_und_ohne_rueckgabewert_definieren|Aufgabe 2]] | [[lehrkraefte:snr:informatik:bruehl-2022:funktionen#aufgabe_3_funktionen_mit_einem_parameter_und_ohne_rueckgabewert_definieren|Aufgabe 3]] |
^ | ''quadrat100'', ''dreieck100'' | ''quadrat'', ''vieleck'' |
^ mit Rückgabewert | [[lehrkraefte:snr:informatik:bruehl-2022:funktionen#aufgabe_5_funktionen_ohne_parameter_und_mit_rueckgabewert_definieren|Aufgabe 5]] | [[lehrkraefte:snr:informatik:bruehl-2022:funktionen#aufgabe_6_funktionen_mit_parameter_und_mit_rueckgabewert_definieren|Aufgaben 6]] [[lehrkraefte:snr:informatik:bruehl-2022:funktionen#aufgabe_7_funktionen_mit_parameter_und_mit_rueckgabewert_definieren|und 7]] | 
^ | ''buchstabeZ'', ''meinAnfangsBuchstabe'' | ''konvertiereFahrenheitInCelsius'', ''laengeDiagonale'', ''brief'' |
</WRAP>

</WRAP>

<WRAP center round info 100%>
Statt sofort mit Aufgabe 2 zu beginnen, programmieren wir zusammen.
<hidden Ungefähr das hier Versteckte.>
Erst
<code python>
forward(50)
right(150)
forward(50)
left(150)
</code>
im Hauptprogramm, dann als Funktion ''spitze'' (erst gar nicht aufrufen, schreibe ''# Definition der Funktion'' dazu), dann 
einmal aufrufen (schreibe ''# Aufruf der Funktion'' dazu), dann mehrfach aufrufen (''repeat 7:'') für Zick-zack-Linie/Treppe, dann nach Funktionsaufruf nach rechts drehen (erst Primzahlwinkel, etwa 61; dann 360/7). 
<hidden Am Ende steht folgendes da:>
<code python>
from gturtle import *

def spitze():     # Definition der Funktion spitze
    forward(50)
    right(150)
    forward(50)
    left(150)     # Ende der Definition der Funktion spitze

makeTurtle()

repeat 7:
    spitze()       # Aufruf der Funktion spitze
    #right(61)
    right(360/7)
</code>
</hidden>
</hidden>
</WRAP>


===== Aufgabe 2, Funktionen ohne Parameter und ohne Rückgabewert definieren =====

<WRAP center round todo 100%>
**Einzelarbeit, ca. 10 Minuten**

Der folgende Code definiert eine Funktion ''quadrat100'' (die keine Parameter entgegennimmt).

Das Schlüsselwort ''def'' für englisch //define// leitet die Definition einer neuen Funktion ein, danach kommt der Funktionsname mit runden Klammern (hier ohne Parameter darin) und danach ein Doppelpunkt. Der eingerückte Code-Block beschreibt genau, was die Funktion macht.
<code python>
from gturtle import *

# In der folgenden Zeile beginnt die Definition der Funktion
def quadrat100():
    repeat 4:
        forward(100)
        right(90)
        
# Hier ist die Definition der Funktion dreieck100 zu ergänzen.        
        
# In der folgenden Zeile beginnt das Hauptprogramm
makeTurtle()

# Ergänze den Code.
</code>
  * Öffne ein neues, leeres Programmfenster in Tigerjython und kopiere das obige Programm hinein.
  * Ergänze das Programm an der angegebenen Stelle um eine Funktion ''dreieck100'', die ein gleichseitiges Dreieck der Seitenlänge 100 zeichnet; dabei soll die Turtle jeweils "nach links abbiegen" und am Ende im selben Zustand wie am Anfang sein. 
  * Ergänze das Hauptprogramm und nutze die Funktion ''dreieck100'', um die Figur unten links zu zeichnen (mit möglichst wenig Code-Zeilen). 
  * Etwas schwieriger: Ändere das Hauptprogramm und nutze die beiden Funktionen ''quadrat100'' und ''dreieck100'', um die Figur unten rechts zu zeichnen. 


{{:lehrkraefte:snr:informatik:bruehl-2022:sechs-dreiecke.png?200|}}
{{:lehrkraefte:snr:informatik:bruehl-2022:sechseck-mit-quadraten.png?200|}}
</WRAP>

===== Aufgabe 3, Funktionen mit einem Parameter und ohne Rückgabewert definieren =====

<WRAP center round todo 100%>
**Einzelarbeit, ca. 10 Minuten**

<WRAP center round info 100%>
Zusätzliche mündliche Erklärung durch mich:
Der folgende Code definiert eine Funktion ''quadrat'' mit einem Parameter ''s'', der die Seitenlänge des Quadrats angibt. Der Parameter ''s'' wird innerhalb der Funktionsdefinition wie eine Variable verwendet. Welchen Wert diese Variable hat, wird bei jedem Funktionsaufruf angegeben. Zeige es im Einzelschrittverfahren!
</WRAP>

<code python>
from gturtle import *

# In der folgenden Zeile beginnt die Definition der Funktion
def quadrat(s):
    repeat 4:
        forward(s)
        right(90)
        
# In der folgenden Zeile beginnt das Hauptprogramm
makeTurtle()

quadrat(100)           # Aufruf der Funktion mit 100 als Parameter/Übergabewert

#
#x = 100
#repeat 7:
#    quadrat(x)           # Aufruf der Funktion mit dem Wert von x als Parameter
#    x = x + 20
</code>

(Für das Folgende kannst du entweder ein neues Programm schreiben oder das obige Programm in eine neues Programmierfenster kopieren und modifizieren.)

Schreibe nun selbst eine Funktion ''vieleck'', die einen Parameter ''n'' entgegennimmt und ein regelmässiges $n$-Eck der Seitenlänge 50 zeichnet; die Turtle soll am Ende im selben Zustand wie am Anfang sein. Nutze deine Funktion, um die folgende Figur zu zeichnen (ein Dreieck in einem Viereck in einem Fünfeck ... undsoweiter ... in einem 11-Eck).

{{:lehrkraefte:snr:informatik:bruehl-2022:vielecke.png?200|}}
</WRAP>



===== Sprungstelle Klasse 1AFGsK: Gehe direkt zu Aufgabe 8! =====

===== Sprungstelle Klasse 1CFP: Erkläre die folgende Infobox, springe dann zu Aufgabe 6 und danach direkt zu Aufgabe 8 (es sei denn, ich verschätze mich zeitlich total, dann einfach direkt mit Aufgabe 4 weiter) =====

===== Addition von Strings und kombinierte Ausgabe von Strings und Zahlen =====

<WRAP center round info 100%>
Strings (= Zeichenketten = Text) werden in Python links und rechts durch Anführungszeichen gekennzeichnet. Beispielsweise ist ''"Hello World!"'' eine String.

Wir spielen mit dem folgenden Programm, bis wir die folgenden Fragen beantworten können:
  * Wie "addiert" Python zwei Strings?
  * Wie kann man den ersten ''print''-Befehl verändern, so dass die Ausgabe ''Grüezi St. Gallen!'' lautet (also mit Leerschlag und Ausrufezeichen).

<code python>
s = "Grüezi"
t = "St. Gallen"

print(s + t)
</code>


Das Programm
<code python>
x = input("Wie alt bist du?")
print("Du bist" + x + "Jahre alt.")
</code>
ist fehlerhaft! Man kann einen String((Tigerjython schreibt "unicode" statt "string" in der Fehlermeldung.)) und eine Zahl in Python **nicht** addieren.

Um bei der Eingabe ''16'' die Ausgabe ''Du bist 16 Jahre alt.'' zu erhalten, ersetzt man am einfachsten die letzte Zeile durch
''print("Du bist" + str(x) + "Jahre alt.)'' und ändert noch eine Kleinigkeit. Die Funktion ''str'' wandelt die Zahlvariable ''x'' in einen String um (liefert also bei Eingabe der Zahl ''16'' den String ''"16"''), den man dann zu den anderen Strings addieren kann.
</WRAP>



===== Aufgabe 4, Rechnen mit Strings (= Zeichenketten) und Zeilenumbruch =====

<WRAP center round todo 100%>
**Einzelarbeit, aber schnell besprechen, ca. 5 Minuten** (Diese Aufgabe hat nichts mit Funktionen zu tun, jedoch wird das hier Gelernte in den folgenden Aufgaben verwendet.)

Strings (= Zeichenketten = Text) werden in Python links und rechts durch Anführungszeichen gekennzeichnet. Beispielsweise ist ''"Hello World!"'' eine String.
Spiele mit dem folgenden Programm, bis du die folgenden Fragen beantworten kannst:
  * Wie "addiert" Python zwei Strings?
  * Wie kann man den ersten ''print''-Befehl verändern, so dass die Ausgabe ''Grüezi St. Gallen!'' lautet (also mit Leerschlag und Ausrufezeichen).
  * Was passiert, wenn man eine Zahl mit einem String multipliziert?
  * Was bewirkt ''\n''?
<code python>
s = "Grüezi"
t = "St. Gallen"

print(s + t)
print(3 * "Sieben!")
print("XXX\nX X\nXXX")
</code>

Hinweis: //n// steht für //new line//, also Zeilenumbruch. In der Fachsprache nennt man ''\n'' einen "Escape character" (deutsch etwa: Fluchtzeichen, Escape-Zeichen).((Die beiden Zeichen ''\'' und ''n'' gehören so eng zusammen, dass sie wie ein Zeichen aufgefasst werden.))
</WRAP>




===== Aufgabe 5, Funktionen ohne Parameter und mit Rückgabewert definieren =====

<WRAP center round todo 100%>
**Einzelarbeit, ca. 8 Minuten**

Der folgende Code definiert eine Funktion ''buchstabeZ'' ohne Parameter, aber mit einem String als Rückgabewert.

Der Rückgabewert steht rechts des Schlüsselworts ''return''.

<code python>
# In der folgenden Zeile beginnt die Definition der Funktion
def buchstabeZ():
    s1 = "XXXXXX\n"
    s2 = "    XX\n"
    s3 = "   XX \n"
    s4 = "  XX  \n"
    s5 = " XX   \n"
    s6 = "XX    \n"
    s7 = "XXXXXX\n"    
    
    # Die folgende Zeile bewirkt, dass die Funktion den String s1 + s2 + s3 + s4 + s5 + s6 berechnet und retourniert.
    return s1 + s2 + s3 + s4 + s5 + s6 + s7

# In der folgenden Zeile beginnt das Hauptprogramm
b = buchstabeZ()
print(buchstabeZ())
</code>

Ändere diesen Code in die Definition einer Funktion ''meinAnfangsBuchstabe'', die den ersten Buchstaben deines Vornamens als "String mit Zeilenumbrüchen" retourniert. Passe das Hauptprogramm so an, dass dein Anfangsbuchstabe 3 Mal ausgegeben wird, jeweils mit einer Leerzeile dazwischen.
</WRAP>

===== Kombinierte Ausgabe von Strings und Zahlen =====

<WRAP center round info 100%>
Das Programm
<code python>
x = input("Wie alt bist du?")
print("Du bist" + x + "Jahre alt.")
</code>
ist fehlerhaft! Man kann einen String((Tigerjython schreibt "unicode" statt "string" in der Fehlermeldung.)) und eine Zahl in Python **nicht** addieren.

Um bei der Eingabe ''16'' die Ausgabe ''Du bist 16 Jahre alt.'' zu erhalten, ersetzt man am einfachsten die letzte Zeile durch
''print("Du bist" + str(x) + "Jahre alt.)'' und ändert noch eine Kleinigkeit. Die Funktion ''str'' wandelt die Zahlvariable ''x'' in einen String um (liefert also bei Eingabe der Zahl ''16'' den String ''"16"''), den man dann zu den anderen Strings addieren kann.
</WRAP>
===== Aufgabe 6, Funktionen mit Parameter und mit Rückgabewert definieren =====

<WRAP center round todo 100%>

**Einzelarbeit, ca. 10 Minuten**

<WRAP center round info 100%>
Zusätzliche mündliche Erklärung durch mich:
Der folgende Code definiert eine Funktion ''konvertiereFahrenheitInCelsius'' mit einem Parameter (der Temperatur in Grad Fahrenheit), die als Rückgabewert die entsprechende Temperatur in Grad Celsius liefert. Erkläre Schlüsselwort ''return''! Zeige es im Einzelschrittverfahren!
</WRAP>

<code python>
# In der folgenden Zeile beginnt die Definition der Funktion
def konvertiereFahrenheitInCelsius(f):
    c = (f - 32) / 1.8
    return c
     
# In der folgenden Zeile beginnt das Hauptprogramm
x = input("Gib die Temperatur in Grad Fahrenheit ein:")
y = konvertiereFahrenheitInCelsius(x)
print(str(x) + " Grad Fahrenheit entspricht " + str(y) + " Grad Celsius.")
</code>


Kopiere den Python-Code unten in ein neues Programmierfenster und ergänze ihn um die Definition der Funktion ''laengeDiagonale'', die als Parameter die Seitenlänge eines Quadrats entgegennimmt und die Länge der Diagonalen berechnet und zurückgibt. Ausserdem ist das Hauptprogramm so zu ergänzen, dass zum Beispiel bei Eingabe 4 die folgende Ausgabe erscheint:

<code text>
Länge der Seite des Quadrats: 4 cm
Länge der Diagonalen: 5.65685424949 cm
</code>

<code python>
# Funktionsdefinition zu ergänzen
 
s = input("Wie lang ist die Seite des Quadrats (in cm)?")

# Ergänze hier den Code für die Ausgabe.
</code>

Hinweis: Die Funktion ''sqrt'' liefert die Quadratwurzel (dabei steht "sqrt" für englisch "square root", also "Quadratwurzel). Beispielsweise liefert ''sqrt(2)'' die Zahl ''1.414213...''.
<hidden Hier ist die Formel versteckt, damit es nicht daran scheitert...>
In einem Quadrat mit Seitenlänge ''a'' hat die Diagonale Länge $\sqrt{2}a$. Das folgt etwa aus dem Satz des Pythagoras oder einfachen geometrischen Überlegungen.
</hidden>
</WRAP>

===== Aufgabe 7, Funktionen mit Parameter und mit Rückgabewert definieren =====

<WRAP center round todo 100%>
**Einzelarbeit, ca. 8 Minuten**

Ergänze den folgenden Code um die Definition der Funktion ''brief'' mit einem String als Parameter und einem String als Rückgabewert, so dass die Ausgabe rechts entsteht.
<WRAP center box 100%>
<WRAP left round box 50%>
<code python>
# Funktionsdefinition zu ergänzen
       
print(brief("Jessica"))
print(brief("Mattia"))
</code>
</WRAP>
<WRAP right round box 45%>
<code text>
Liebe(r) Jessica
Liebe(r) Mattia
</code>
</WRAP>
</WRAP>

<hidden Bonus:>
Erzeuge nun mit demselben Hauptprogamm die Ausgabe (nur die Funktion ''brief'' ist zu ändern):

{{:lehrkraefte:snr:informatik:bruehl-2022:brief.png?200|}}

<hidden Hinweis:>
Nutze das Escape-Zeichen ''\n'' aus [[lehrkraefte:snr:informatik:bruehl-2022:funktionen#aufgabe_4_rechnen_mit_strings_zeichenketten_und_zeilenumbruch|Aufgabe 4]] und Addition von Strings.
</hidden>
</hidden>
</WRAP>


===== Aufgabe 8, Mäander (Ornamentik), mehrere Funktionen kombinieren =====

<WRAP center round todo 100%>
**Einzelarbeit, ca. 20 Minuten**

{{:lehrkraefte:snr:informatik:bruehl-2022:rechteck-fries-dick.png?600|}}  {{:lehrkraefte:snr:informatik:bruehl-2022:rechteck-fries-duenn.png?600|}}

Ziel ist, das linke Muster effizient zu zeichnen. Gewisse Teilstrukturen wiederholen sich: Das rote Ornament im Muster rechts kommt $8+5+8+5 = 26$ Mal vor, der grüne Pfad als "verbindende Eckbewegung" 4 Mal. Deshalb ist es sinnvoll, diese Teilstrukturen von Funktionen zeichnen zu lassen.

Schreibe wie folgt ein Programm dafür:
  - Definiere eine Funktion ''ornament'': Sie soll den roten Streckenzug im rechten Muster zeichnen (links oben beginnend, wobei wir annehmen, dass die Turtle aktuell nach rechts schaut; am Ende soll sie dieselbe Blickrichtung haben wie am Anfang). Hinweis: Die roten Teilstücke sind 60, 40 und 20 Pixel lang. 
  - Teste deine Funktion ''ornament''.
  - Definiere eine Funktion ''wiederholeOrnament'' mit Parameter ''n'': Sie soll ''n'' Mal die Funktion ''ornament'' aufrufen. (Dabei lernst du, dass eine Funktion eine andere aufrufen kann!)
  - Definiere eine Funktion ''eckBewegung'': Sie soll den grünen Streckenzug zeichnen (rechts unten beginnend, wobei wir annehmen, dass die aktuelle Blickrichtung rechts ist; die Turtle soll dann am Ende nach oben schauen).
  - Schreibe nun das Hauptprogramm und verwende darin diese Funktionen in geschickter Weise, so dass ein Muster wie rechts oben (aber alles in Schwarz) entsteht. (Wenn du es genauso gross zeichnen willst, musst du die Schildkröte anfangs in die linke untere Ecke des Fensters bewegen und in die richtige Richtung schauen lassen.)
  - Setze schliesslich die Stiftdicke auf 10, um das linke Muster zu bekommen.

<hidden Wenn du Hilfe benötigst: Hier ist das Gerüst eines Python-Programms für eine mögliche Lösung.>
<code python>
from gturtle import *    

def ornament():
    print("Bitte definiere mich!")
    # Zu ergänzen.
    
def wiederholeOrnament(n):
    print("Bitte definiere mich!")
    # Zu ergänzen.

def eckBewegung():
    print("Bitte definiere mich!")
    # Zu ergänzen.

makeTurtle()
hideTurtle()

# Bewege die Turtle nach links unten und lass sie nach rechts schauen.
penUp()
backward(180)
right(90)
backward(290)
penDown()

setPenColor("black")
penWidth(2)

# Hier sind die oben definierten Funktionen in geeigneter Weise aufzurufen, eventuell mit repeat 2.
</code>
</hidden>

<hidden Bonusaufgaben (bitte ausklappen)>
Zeichne ähnliche Muster! Zur Inspiration:
  * [[https://de.wikipedia.org/wiki/M%C3%A4ander_(Ornamentik)|Wikipedia: Mäander (Ornamentik)]]
  * [[https://de.wikipedia.org/wiki/Fries|Wikipedia: Fries]]
  * [[https://de.wikipedia.org/wiki/Ornament|Wikipedia: Ornament]]
</hidden>
</WRAP>



===== Hausaufgabe (kann eventuell während der Lektion begonnen werden) =====

<WRAP center round todo 100%>
  * Aufgabe 8 (Mäander) oder eine Variation deiner Wahl davon von ähnlicher Schwierigkeit

Abgabe bis **spätestens Sonntagabend 23:59 Uhr** vor der nächsten Doppellektion über den folgenden Link:
  * [[https://bldsg-my.sharepoint.com/:f:/g/personal/olaf_schnuerer_ksbg_ch/EmI8Oy4_wg9Cly2BJUwO6P4Bc5KDc-H7se7d4zRjWaK7zA|Klasse 1AFGsK]]
  * [[https://bldsg-my.sharepoint.com/:f:/g/personal/olaf_schnuerer_ksbg_ch/EsO5WdmLhbxImi-Bfes3NIIBeSxcGJOilPde10OlaK240A|Klasse 1CFP]]
</WRAP>



===== Überlegungen nach der Pause (wann auch immer diese stattfindet)=====

  * Wozu sind Funktionen gut?
  * Wie unterscheiden sich Funktionsaufruf und Funktionsdefinition?
  * Was ist ein Parameter?
  * Was ist ein Rückgabewert?

===== Struktur von Programmen ====

<WRAP center round info 100%>
Python ist relativ tolerant, wo man Funktionen definiert. Trotzdem ist die folgende Reihenfolge zu empfehlen:

<code python>
# Import von Bibliotheken
from ... import ...

# Definitionen von Funktionen
def ...:

def ...:

# Beginn des Hauptprogramms, z. B. mit
makeTurtle()

</code>

  - Zuerst ''import''-Anweisungen -- sie stellen Funktionen (aus sogenannten Bibliotheken) bereit, die andere Leute bereits definiert haben.((Hier werden auch sogenannte Konstanten definiert, also Variablen, die ihren Startwert beibehalten.))
  - Leerzeile
  - Funktionsdefinitionen (jeweils mit ''def'' eingeleitet); man nennt Funktionen auch **Teil-** oder **Unterprogramme**; gibt es mehrere Funktionsdefinitionen, so werden sie durch mindestens eine Leerzeile getrennt.
  - Leerzeile
  - Hauptprogramm (erst hier steht so etwas wie ''makeTurtle()'')

Im Übrigen ist es guter Stil, Kommentare im Programm anzubringen (alles nach ''#'' wird vom Computer ignoriert). Beispielsweise ist es zu empfehlen, bei jeder Funktion dazuzuschreiben, was sie tut und wie sie von eventuellen Parametern abhängt. Auch Leerzeilen machen ein längeres Programm oft übersichtlicher.
</WRAP>

<hidden Hier ist ein Beispiel eines gut strukturierten und kommentierten Programms (beachte, dass eine Funktion auch eine andere Funktion aufrufen kann):>
<code python>
# Header: Anweisungen zum Import von Funktionen aus Bibliotheken
from gturtle import *
from random import *

# Definitionen von Funktionen

# Die folgende Funktion setzt die Farbe der Schildkröte zufällig auf rot, grün oder blau.
def waehleZufallsFarbe():
    z = random()
    if z < 0.3333:
        setPenColor("red")
    elif z < 0.6666:
        setPenColor("blue")
    else:
        setPenColor("green")

# Die folgende Funktion zeichnet ein regelmässiges n-Eck. Die Farbe jeder Seite wird zufällig gewählt.
def vieleck(n):
    repeat n:
        waehleZufallsFarbe()
        forward(60)
        right(360/n)

# Beginn des Hauptprogramms

# Erzeuge die Turtle in Fenstermitte mit Blickrichtung nach vorne, mach sie unsichtbar und setze die Stiftdicke auf 4.
makeTurtle()
hideTurtle()
penWidth(4)

# Bewege die Turtle ohne zu zeichnen 280 Pixel zurück.
penUp()
backward(280)
penDown()

# Zeichne sukzessive eine 3-Eck, ein 6-Eck etc. bis zum 18-Eck. Dazwischen wird die Turtle unsichtbar etwas nach vorne bewegt.
m = 3
repeat 6:
    vieleck(m)
    m = m + 3
    penUp()
    forward(70)
    penDown()
</code>
</hidden>
====== Zusammenfassung und Feedback ======

===== Zusammenfassung =====

<hidden Was hast du gelernt? Wozu ist es gut? Erst selbst überlegen!> 
  * Modularisierung / modularer Entwurf / Baukastenprinzip
  * Ich weiss, wie man Funktionen mit/ohne Parameter und mit/ohne Rückgabewert definiert.
  * Funktionen dienen der besseren Strukturierung von Programmen.
  * Sie sind besonders nützlich, wenn man gewisse Programmteile mehrfach verwenden möchte.
  * Teilweise: Ich weiss, wie man mit Strings rechnet (Addition zweier Strings, Multiplikation eines Strings mit einer Zahl) und was ''"\n"'' bedeutet.
</hidden>


===== Konstruktives Feedback (freiwillig) =====

Schreibt bitte auf die Post-it-Zettel:
  * Was euch heute gefallen hat.
  * Statt aufzuschreiben, was euch nicht gefallen hat: Macht einen Verbesserungsvorschlag, was ich das nächste Mal besser machen soll.




===== Bonusaufgabe 1 (leicht), Funktionen mit mehreren Parametern und ohne Rückgabewert definieren =====

<WRAP center round todo 100%>
**Einzelarbeit, ca. 6 Minuten**

Genauso kann man Funktionen mit mehreren Parametern definieren:
Ergänze den folgenden Code um die Definition der Funktion ''polygon'' mit vier Parametern ''n'', ''dicke'', ''farbe'', ''s'', so dass die Zeichnung rechts entsteht.((Polygon ist das Fremdwort für //Vieleck//, von griechisch πολυς polys //viel// und γωνια gonia //Ecke// oder //Winkel//.))
<WRAP left round box 50%>
<code python>
from gturtle import *

def polygon(n, dicke, farbe, s):
# Rest der Funktionsdefinition zu ergänzen
       
makeTurtle()
hideTurtle()
polygon(7, 12, "green", 140)
polygon(5, 10, "red", 120)
polygon(3, 8, "blue", 100)
</code>
</WRAP>
<WRAP right round box 40%>
{{:lehrkraefte:snr:informatik:bruehl-2022:several-polygons.png?200|}}
</WRAP>
</WRAP>

===== Bonusaufgabe 2 (leicht), Funktionen mit mehreren Parametern und mit Rückgabewert definieren =====

<WRAP center round todo 100%>
**Einzelarbeit, ca. 8 Minuten**

Schreibe eine Funktion ''hypotenuse'', die die Länge der beiden Katheten eines rechtwinkligen Dreiecks vom Benutzer entgegennimmt und die Länge der Hypotenuse berechnet (mit Hilfe des Satzes des Pythagoras).

Die Ausgabe soll wieder gut lesbar sein und beispielsweise wie folgt aussehen. 
<code text>
Kathetenlängen: 3 und 4
Länge der Hypotenuse: 5
</code>

Hinweis: Die Funktion ''sqrt'' liefert die Quadratwurzel (dabei steht "sqrt" für englisch "square root", also "Quadratwurzel). Beispielsweise liefert ''sqrt(2)'' die Zahl ''1.414213...''.
<hidden Hier ist die Formel versteckt, damit es nicht daran scheitert...>
Wenn die beiden Katheten (= "kurzen Seiten") in einem rechtwinkligen Dreieck die Längen ''a'' und ''b'' haben, so hat die Hypotenuse (= "längste Seite", dem rechten Winkel gegenüberliegend) die Länge
<WRAP center round box 100%>
$$c = \sqrt{a^2+b^2}$$
</WRAP>

</hidden>
</WRAP>

===== Bonusaufgabe 3: Kreis aus St. Galler Wappen oder Blumen =====

<WRAP center round todo 100%>
Nutze die beiden "aufklappbaren" Programme, um Funktionen ''stGallen'' und/oder ''blume'' zu definieren. Verwende diese kreativ. Beispielsweise kannst du 
  - Bilder wie unten abgebildet zeichnen;
  - das [[lehrkraefte:snr:informatik:bruehl-2022:auswahl#aufgabe_4_zeichenprogramm_ferngesteuerte_turtle|Zeichenprogramm aus dem Abschnitt über if-Selektion]] erweitern, so dass auf Tastendruck das St. Galler Wappen (etwa per Taste ''s'' wie //St. Gallen//) oder die Blume (etwa per Taste ''f'' wie //flower//) gezeichnet wird.

<hidden Hier ist der Code von Esteban versteckt, der das St. Galler Wappen zeichnet.>
<code python>
# Dank an Esteban für das Zeichnen des Wappens!
# Ich habe seinen Code etwas modifiziert, so dass das Erstellen der Funktion leichter geht.

from gturtle import *
makeTurtle()
hideTurtle()

# Speichere aktuelle Position und Richtung etc.
x = getX()
y = getY()
h = heading()
d = getPenWidth()
penFarbe = getPenColor()
fuellFarbe = getFillColor()


# Bewege zum Punkt links am Wappen, wo Krümmung beginnt
setPenColor("black")
penUp()
left(90)
repeat 90:
    forward(1)
    right(1)
penDown()

# Male Wappenumrandung.
setFillColor("white")
startPath()
penWidth(5)
right(180)
repeat 180:
    left(1)
    forward(1)
forward(100)
left(90)
forward(115)
left(90)
forward(100)

# Färbe Inneres des Wappens weisst.
fillPath()

# Gehe unsichtbar nach innen.
penWidth(2)
penUp()
forward(40)
left(90)
forward(55)
penDown()

# Zeichne Rutenbündel mit Beil
forward(5)
left(90)
forward(10)
right(90)
forward(12.5)
left(90)
forward(90)
left(90)
forward(12.5)
right(90)
forward(9.5)
right(45)
forward(5)
left(90)
forward(5)
right(45)
forward(9.5)
left(90)
forward(5)
left(90)
forward(9.5)
right(90)
forward(4)
right(45)
forward(14)
left(90)

# Klinge des Beils
repeat 9:
    left(8.2)
    forward(2.9)
left(93)
forward(14)
right(32)
forward(4)
right(90)
forward(9.5)
right(90)
forward(12.5)
left(90)
forward(90)
left(90)
forward(12.5)
right(90)
forward(10)
left(90)
forward(5)
penUp()
forward(5)
setFillColor(0, 143, 55)
fill()

# Setze Turtle auf gespeicherte Position und Richtung etc.
penUp()
moveTo(x,y)
setHeading(h)
penWidth(d)
setPenColor(penFarbe)
setFillColor(fuellFarbe)
penDown()
</code>
</hidden>

<hidden Hier ist der Code von Gioia versteckt, der eine Blume zeichnet.>
<code python>
# Dank an Gioia!
# Ich habe ihren Code etwas modifiziert (aber nicht besonders elegant), so dass das Erstellen der Funktion leichter geht.
from gturtle import *
makeTurtle()
hideTurtle()
#speed(2000)

# Speichere aktuelle Position und Richtung etc.
x = getX()
y = getY()
h = heading()
d = getPenWidth()
penFarbe = getPenColor()

f = 0.4 # Verkleinerungsfaktor,
        # denn Gioias Blume war mir zu gross. 
        # Alle Streckenangaben in den Zeichenbefehlen werden mit diesem Faktor multipliziert.
        # Wer mag, kann auch diesen Faktor als Parameter an die Funktion übergeben.

# Ohne zu zeichnen vom "Fuss des Stängels" zur Blütenmitte gehen (das sind die Stängelzeichenbefehle rückwärts).
penUp()
right(180)
forward(-170 * f)
forward(-69 * f)
right(-90)
forward(-7 * f)
right(-90)
penDown()

# Blüte zeichnen.
setPenColor("violet")
penWidth(int(5 * f))
penUp()
forward(60 * f)
setPenColor("pink")
dot(80 * f)
right(120)
forward(60 * f)
penUp()
dot(80 * f)
right(70)
forward(70 * f)
dot(80 * f)
right(75)
penUp()
forward(70 * f)
dot(80 * f)
right(85)
penUp()
forward(70 * f)
dot(80 * f)

# Obige Befehle rückwärts, damit wieder in Blütenmitte.
forward(-70 * f)
right(-85)
forward(-70 * f)
right(-75)
forward(-70 * f)
right(-70)
forward(-60 * f)
right(-120)
forward(-60 * f)

# Zeichne Rest der Blüte und Stängel.
setPenColor("violet")
dot(60 * f)
right(90)
forward(7 * f)
right(90)
setPenColor("lightgreen")
penUp()
forward(69 * f)
penDown()
penWidth(int(15 * f))
forward(170 * f)

# Setze Turtle auf gespeicherte Position und Richtung etc.
penUp()
moveTo(x,y)
setHeading(h)
penWidth(d)
setPenColor(penFarbe)
penDown()
</code>
</hidden>

{{:lehrkraefte:snr:informatik:bruehl-2022:st-galler-wappen-kreis.png?400|}}
{{:lehrkraefte:snr:informatik:bruehl-2022:blumenkranz.png?200|}}
</WRAP>

===== Fragebox - auch zum Besprechen von Programmen während der Lektion (NICHT für Hausaufgaben) =====

Bitte einfach am Anfang des Programms oder der eingereichten Datei die Frage aufschreiben (mit oder ohne Hashtag ''#'' als Kommentareinleitungszeichen am Zeilenanfang).

[[https://bldsg-my.sharepoint.com/:f:/g/personal/olaf_schnuerer_ksbg_ch/EmLIcTN64lJIlEKu0EyiDYoBg9smMusTs1nVj04-F1tEFQ|Link zur Fragebox]]



===== Lösungsvorschläge =====

<hidden zu ergänzen>
<code python>
</code>
</hidden>

<hidden Kreis aus St. Galler Wappen>
<code python>
# Dank an Esteban für das Zeichnen des Wappens!

from gturtle import *

def stGallen():  
    
    # Speichere aktuelle Position und Richtung
    x = getX()
    y = getY()
    h = heading()
    setPenColor("black")

    # Bewege zum Punkt links am Wappen, wo Krümmung beginnt
    penUp()
    left(90)
    repeat 90:
        forward(1)
        right(1)
    penDown()
    
    # Male Wappenumrandung.
    setFillColor("white")
    startPath()
    penWidth(5)
    right(180)
    repeat 180:
        left(1)
        forward(1)
    forward(100)
    left(90)
    forward(115)
    left(90)
    forward(100)
    
    # Färbe Inneres des Wappens weisst.
    fillPath()
    
    # Gehe unsichtbar nach innen.
    penWidth(2)
    penUp()
    forward(40)
    left(90)
    forward(55)
    penDown()
    
    # Zeichne Rutenbündel mit Beil
    forward(5)
    left(90)
    forward(10)
    right(90)
    forward(12.5)
    left(90)
    forward(90)
    left(90)
    forward(12.5)
    right(90)
    forward(9.5)
    right(45)
    forward(5)
    left(90)
    forward(5)
    right(45)
    forward(9.5)
    left(90)
    forward(5)
    left(90)
    forward(9.5)
    right(90)
    forward(4)
    right(45)
    forward(14)
    left(90)
    
    # Klinge des Beils
    repeat 9:
        left(8.2)
        forward(2.9)
    left(93)
    forward(14)
    right(32)
    forward(4)
    right(90)
    forward(9.5)
    right(90)
    forward(12.5)
    left(90)
    forward(90)
    left(90)
    forward(12.5)
    right(90)
    forward(10)
    left(90)
    forward(5)
    penUp()
    forward(5)
    setFillColor(0, 143, 55)
    fill()

    # Setze Turtle auf gespeicherte Position und Richtung
    moveTo(x,y)
    setHeading(h)

makeTurtle()
hideTurtle()

n = 21
enableRepaint(False)

penUp()
left(90)
forward(150)
right(90)

repeat 4 * n:
    stGallen()
    repaint()
    right(360/n)
    forward(40)
    delay(100)
</code>
</hidden>

<hidden Kreis aus Blumen>
<code python>
from gturtle import *

def stGallen():  
    hideTurtle()
    x = getX()
    y = getY()
    h = heading()
    d = getPenWidth()
    penFarbe = getPenColor()
    fuellFarbe = getFillColor()

    setPenColor("black")

    penUp()
    left(90)
    repeat(90):
        forward(1)
        right(1)
    penDown()
    
    setFillColor("white")
    startPath()
    penWidth(5)
    right(180)
    repeat(180):
        left(1)
        forward(1)
    forward(100)
    left(90)
    forward(115)
    left(90)
    forward(100)
    fillPath()
    
    penWidth(2)
    penUp()
    forward(40)
    left(90)
    forward(55)
    penDown()
    forward(5)
    left(90)
    forward(10)
    right(90)
    forward(12.5)
    left(90)
    forward(90)
    left(90)
    forward(12.5)
    right(90)
    forward(9.5)
    right(45)
    forward(5)
    left(90)
    forward(5)
    right(45)
    forward(9.5)
    left(90)
    forward(5)
    left(90)
    forward(9.5)
    right(90)
    forward(4)
    right(45)
    forward(14)
    left(90)
    repeat(9):
        left(8.2)
        forward(2.9)
    left(93)
    forward(14)
    right(32)
    forward(4)
    right(90)
    forward(9.5)
    right(90)
    forward(12.5)
    left(90)
    forward(90)
    left(90)
    forward(12.5)
    right(90)
    forward(10)
    left(90)
    forward(5)
    penUp()
    forward(5)
    setFillColor(0, 143, 55)
    fill()
    moveTo(x,y)
    setPenColor(penFarbe)
    setFillColor(fuellFarbe)
    penWidth(d)
    setHeading(h)
    penDown()

def blume():
    hideTurtle()
        
    # Speichere aktuelle Position und Richtung etc.
    x = getX()
    y = getY()
    h = heading()
    d = getPenWidth()
    penFarbe = getPenColor()
    
    f = 0.4 # Verkleinerungsfaktor
    penUp()
    right(180)
    forward(-170 * f)
    forward(-69 * f)
    right(-90)
    forward(-7 * f)
    right(-90)
    penDown()
    
    setPenColor("violet")
    penWidth(int(5 * f))
    penUp()
    forward(60 * f)
    setPenColor("pink")
    dot(80 * f)
    right(120)
    forward(60 * f)
    penUp()
    dot(80 * f)
    right(70)
    forward(70 * f)
    dot(80 * f)
    right(75)
    penUp()
    forward(70 * f)
    dot(80 * f)
    right(85)
    penUp()
    forward(70 * f)
    dot(80 * f)
    
    forward(-70 * f)
    right(-85)
    forward(-70 * f)
    right(-75)
    forward(-70 * f)
    right(-70)
    forward(-60 * f)
    right(-120)
    forward(-60 * f)
    
    setPenColor("violet")
    dot(60 * f)
    right(90)
    forward(7 * f)
    right(90)
    setPenColor("lightgreen")
    penUp()
    forward(69 * f)
    penDown()
    penWidth(int(15 * f))
    forward(170 * f)
    
    # Setze Turtle auf gespeicherte Position und Richtung etc.
    penUp()
    moveTo(x,y)
    setHeading(h)
    penWidth(d)
    setPenColor(penFarbe)
    penDown()

makeTurtle()
hideTurtle()

penUp()

n = 9
enableRepaint(False)
 
penUp()
left(90)
forward(50)
right(90)
 
repeat n:
    forward(10)
    right(360/n)
    left((180 + 360/n)/2)
    penDown()
    blume()
    penUp()
    repaint()
    right((180 + 360/n)/2)
</code>
</hidden>



===== Link zur Kursseite =====

[[lehrkraefte:snr:informatik:bruehl-2022:|Zur Kursseite]]