Gemeinsam an Tafel

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

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.

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.

• Ö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.

Einzelarbeit, ca. 10 Minuten

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

(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).

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?

s = "Grüezi"
t = "St. Gallen"
 
print(s + t)
print(3 * "Sieben!")
print("XXX\nX X\nXXX")

Hinweis: n steht für new line, also Zeilenumbruch. In der Fachsprache nennt man \n einen “Escape character” (deutsch etwa: Fluchtzeichen, Escape-Zeichen).²⁾

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.

# 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())

Ä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.

Einzelarbeit, ca. 10 Minuten

# 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.")

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:

Länge der Seite des Quadrats: 4 cm
Länge der Diagonalen: 5.65685424949 cm

# Funktionsdefinition zu ergänzen
 
s = input("Wie lang ist die Seite des Quadrats (in cm)?")
 
# Ergänze hier den Code für die Ausgabe.

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….

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.

# Funktionsdefinition zu ergänzen
 
print(brief("Jessica"))
print(brief("Mattia"))

Liebe(r) Jessica
Liebe(r) Mattia

Einzelarbeit, ca. 20 Minuten

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:

1. 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.
2. Teste deine Funktion ornament.
3. 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!)
4. 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).
5. 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.)
6. Setze schliesslich die Stiftdicke auf 10, um das linke Muster zu bekommen.

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.

• 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:

• Klasse 1AFGsK
• Klasse 1CFP

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.⁵⁾

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)

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.

Kathetenlängen: 3 und 4
Länge der Hypotenuse: 5

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….

Nutze die beiden “aufklappbaren” Programme, um Funktionen stGallen und/oder blume zu definieren. Verwende diese kreativ. Beispielsweise kannst du

1. Bilder wie unten abgebildet zeichnen;
2. das 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.

# 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()

# 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()