Inhaltsverzeichnis

Programmieren Teil 4 – Funktionen (Unterprogramme)

Programmieren Teil 4 – Funktionen (Unterprogramme)

Dieses Seite ist die Fortsetzung von Programmieren Teil 3 – Listen (mit der while-Schleife).

1. 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: „Was, wenn ich gleich mehrere Codezeilen irgendwo unterbringen will?“. Für diese Idee gibt es Funktionen, die wir auch Unterprogramme nennen können.

Auftrag 1 – Bereits bekannte Funktionen anschauen

In Python sind viele Funktionen schon eingebaut. Du hast ein paar davon schon oft verwendet – zum Beispiel print, input und len:

print("Hallo")
name = input("Wie heisst du?")
n_letters = len(name)
print(f"Dein Name hat {n_letters} Buchstaben.")

Aufgabe

Zu zweit: Besprecht folgende Fragen. Vergleicht dann mit der Lösung unten.

Was ist allen drei Funktionen gemeinsam?
Worin unterscheiden sich die Funktionen strukturell (abgesehen davon, dass sie unterschiedliche Namen haben und unterschiedliche Zwecke erfüllen)?

2. Theorie

Auftrag 2 – Eine Funktion (ein Unterprogramm) erstellen und verwenden

Mit folgendem Code zeichnet die Turtle einen violeten Punkt, dreht 90 Grad nach rechts und fährt um 40 Pixel weiter:

from gturtle import * 
karl = Turtle()
 
karl.setPenColor("purple")
karl.dot(40)
karl.right(90)
karl.forward(40)

Die letzten vier Codezeilen aus obigem Code packen wir nun in eine Funktion namens „purple_dot“. Dann rufen wir die Funktion viermal nacheinander auf:

from gturtle import * 
karl = Turtle()
 
def purple_dot():
    karl.setPenColor("purple")
    karl.dot(40)
    karl.right(90)
    karl.forward(40)
 
purple_dot()
purple_dot()
purple_dot()
purple_dot()

Beachte:

Um eine Funktion zu erstellen, benötigst du das Schüsselwort def (die Funktion wird hier definiert).
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

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:

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.

from gturtle import * 
karl = Turtle()
 
def my_dot(color):
    karl.setPenColor(color)
    karl.dot(40)
    karl.right(90)
    karl.forward(40)
 
my_dot("red")
my_dot("blue")
my_dot("orange")
my_dot("green")

Aufgabe

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¹⁾ Punkte in den Grössen 20, 30, 40, 30, siehe Bild.

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

def schnitt(zahl1, zahl2):
    summe = zahl1 + zahl2
    return summe/2
 
print(schnitt(4, 5))

Beachte:

Das Schlüsselwort return bewirkt Folgendes:
1. Die Funktion wird sofort verlassen.
2. 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?

3. 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:

Hinweis: Eine Blume wie im Bild kann aus sechs 30-px-Punkten (dot) auf einem Kreis (rightArc 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:

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:

x = 0
while x < 600:
    blume("red", x, 0)
    x = x + 100

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:

colors = ["orange", "purple", "blue", "crimson", "pink", "violet"]
xpositions = [0,55,105,145,200,225]
ypositions = [0,25,-10,25,50,10]

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:

NA4 – Wer hat die schönste Blumenwiese?

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

Wettbewerb: Sende dein schönstes Blumenbild via Teams der LP und nimm an der Wahl zur schönsten Blumenwiese teil!

Aufgaben NB – Funktionen (Unterprogramme) mit Rückgabewerten

Die folgenden Aufgaben behandeln Funktionen mit Argumenten und 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

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:

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

NB4 – Minimalwert aus drei Zahlen

Logische Verknüpfungen

Mit den Schlüsselworten and und orkannst du Bedingungen miteinander verknüpfen. Mit dem Schlüsselwort not kannst du Bedingungen und Ausdrücke invertieren. Hier drei Beispiele:

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

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.

Probiere es aus – teste den Code für alle drei Möglichkeiten!

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:

print(min_von_drei(1,2,3))
print(min_von_drei(5,6,4))
print(min_von_drei(9,7,8))

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:

list1 = [11, 16, 5, 12, 3, 13] 
list2 = [13, 2, 5, 10, 1, 17, 5, 25]
list3 = [-25, -13, -3, -33]

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:

zahl = input("Bitte ganze Zahl eingeben:")
 
if ist_gerade(zahl):
    print("Die Zahl ist gerade")
else:
    print("Die Zahl ist ungerade")

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

Schreibe eine Funktion pizza_lieferung(n), die ausgehend von der Anzahl Pizzen den Preis für die Pizzalieferung berechnet und zurückgibt. Das Argument n gibt die Anzahl Pizzen an. Jede Pizza kostet 12 Franken. Die Liefergebühren betragen 20 Franken. Ab einem Bestellwert von 50 Franken entfallen die Liefergebühren. Teste deine Funktion.

Frage: Wenn ihr zu viert seid: Bestellt ihr besser 4 oder 5 Pizzen?

NB8 – Nächte im Hotel

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.

Teste deine Funktion mit folgendem Code:

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

Aufgaben NC – Gemischte Aufgaben zu Funktionen

Die folgenden Aufgaben behandeln Funktionen mit und ohne Argumente oder 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).

Wenn du das geschafft hast, darfst du folgendes Video schauen: Hexagons are the Bestagons.

NC2 – Random Dots

Schreibe eine Funktion punkte(min, max, farben) gemäss folgenden Anforderungen:
1. Die Argumente min und max geben an, wie viele Punkte mindestens und höchstens gezeichnet werden.
2. Das Argument farben ist eine Liste mit Farbnamen.
3. Die Funktion zeichnet eine zufällige Anzahl Punkte (20 px) im gewünschten Bereich.
4. Für jedem Punkt wird eine zufällige Farbe aus der Farbliste gewählt.
5. Die Position jedes Punktes wird ebenfalls zufällig bestimmt: Die x-Position im Bereich -250 bis 250, die y-Position im Bereich -100 bis 100.
6. Die Funktion gibt zurück, wie viele Punkte sie gezeichnet hat.
Schreibe ein Programm, das die Funktion punkte verwendet:
1. Erstelle eine Liste mit vier bis sieben Farben.
2. Rufe die Funktion auf (mit beliebigen Werten für min und max sowie mit der Farbliste) und gib eine Meldung in folgender Form aus: „Es wurden 14 Punkte gezeichnet“.

NC3 – Crimson & Clover

Crimson & Clover ist der Titel dieses Liedes von Tommy James and the Shondells.

Schritt 1 – Herzblatt

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.

Schritt 2 – Kleeblätter

Schreibe eine weitere Funktionen kleeblatt3(radius), die ein grünes, 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 dunkelgrünes, vierblättriges Kleeblatt malt.

Schritt 3 – Crimson & Clover

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.

Zusatzaufgabe (Optional)

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:

import math
print(math.sqrt(4))

NC4 – Text rückwärts

Strings vs. Listen

Texte werden in python als Strings (engl. „Schnur“ oder „Kette“) bezeichnet. Ein Text besteht aus mehreren Buchstaben und ist damit eine Aneinanderreihung von Buchstaben – sozusagen eine Kette von Buchstaben.

Strings haben gewisse Ähnlichkeit mit Listen: Auch in Listen sind mehrere Elemente aneinander gehängt. Hier vergleichen wir Listen mit Strings anhand einiger Befehle/Operationen:

Befehle mit Listen:

my_list = [] # Leere Liste erstellen
numbers = [3,9,27] # Liste mit Inhalt erstellen
numbers.append(81) # Der Liste ein Element anfügen
n = numbers[2] # Bestimmtes Element in Liste wählen
print(n) # Gibt 27 aus

Befehle mit Strings:

my_text = "" # Leeren Text erstellen
name = "Immanuel" # Text mit Inhalt erstellen
name = name + " Kant" # Dem Text einen Text anfügen
b = name[5] # Bestimmten Buchstaben im Text wählen
print(b) # Gibt 'u' aus

Die Funktion len() funktioniert sowohl für Listen als auch für Strings.

Schreibe eine Funktion text_reverse(text), die einen Text rückwärts zurückgibt:

Zum Beispiel soll der Aufruf text_reverse(„Roti Rösli im Garte“) den Text „etraG mi ilsöR itoR“ zurückgeben.
Verwende eine While-Schleife, um durch den String (den Text) zu gehen.
- Hinweis: Python böte mit der String-Slicing-Syntax eine sehr kurze Lösung für diese Aufgabe. Wir verzichten hier aber auf String Slicing und bleiben vorerst bei der guten alten while-Schleife.
Teste deine Funktion.

NC5 – Abstände ersetzen

Schreibe eine Funktion replace_spaces(text, char). Die Funktion ersetzt alle Abstände (spaces) in text durch das Zeichen char und gibt den neuen Text zurück. Zum Beispiel gibt der Aufruf replace_spaces(„Roti Rösli im Garte“, '-') den Text „Roti-Rösli-im-Garte“ zurück. Teste deine Funktion.

Hinweis: Mit eckigen Klammern können wir zwar einen Buchstaben aus einem String auslesen. Anders als bei Listen können wir die eckigen Klammern aber nicht nutzen, um einen bestimmten Buchstaben eines Strings zu verändern.

NC6 – Wörter rückwärts (Challenge)

Schreibe eine Funktion words_reverse(text), die die Wortfolge eines Textes umdreht und den neuen Text zurückgibt. Zum Beispiel soll der Aufruf words_reverse(„Roti Rösli im Garte“) den Text „Garte im Rösli Roti“ zurückgeben.

Schritt 1

Schreibe zuerst eine Funktion word_list(text), die jedes einzelne Wort in text in einer Liste auflistet und diese Liste zurückgibt. Teste die Funktion.

Schritt 2

Schreibe nun die Funktion words_reverse(text) mithilfe der Funktion word_list(text). Teste die Funktion.

4. Aufgaben O – Funktionen für Fortgeschrittene

O1 – Weitere Nächte im Hotel

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

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:

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

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.

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.

O3 – Fibonacci-Spirale

Infomiere dich zuerst über die Informiere dich über die Fibonacci-Folge und erstelle dann Funktionen, mit denen Du eine Fibonacci-Spirale wie im Bild malen kannst.

Erstelle eine Funktion fibonacci(n), die eine Liste mit den ersten n Zahlen der Fibonacci-Folge zurückgibt. Zum Beispiel gibt fibonacci(7) die Liste [0, 1, 1, 2, 3, 5, 8] zurück. Teste die Funktion.
Erstelle eine Funktion viertelrkreis(radius, farbe), die einen Viertelkreis in gewünschter Farbe zeichnet. Tipp: Die Turtle sollte den Kreis so zeichnen, dass sie mit dem Bogen beginnt und am Ende an derjenigen Position ist, an der der nächste Kreisbogen beginnen kann. Teste deine Funktion, indem du sie mehrmals, mit immer grösserem Radius, aufrufst.
Erstelle eine Funktion fibo_spirale(n), die eine fibonacci-Spirale aus n Viertelkreisen wie im Bild malt: Die Farben der Viertelkreise wechseln zwischen blau und rot. Verwende die bereits erstellten Funktionen fibonacci und viertelkreis. Teste deine Funktion.

Zusatzaufbabe

Erstelle eine neue Funktion fibo_spirale2(n, colors). Dieser Funktion wird zusätzlich eine Farbliste beliebiger Länge mitgegeben. Die Funktion zeichnet die Viertelkreise gemäss der Farbliste. Für folgenden Code sollte nebenstehendes Bild entstehen.

farben = ["crimson", "orange", "maroon", "gold"]
fibo_spirale2(9, farben)

O4 – Siebensegment-Anzeige

Die Siebensegmentanzeige ist grossartig: Man benötigt nur 7 längliche Lämpchen und kann damit nicht nur die Ziffern 0 bis 9, sondern auch viele Buchstaben anzeigen! In dieser Aufgabe soll deine Turtle als Siebensegmentanzeige funktionieren.

Schritt 1 – Einzelnes Segment zeichnen

Erstelle eine Funktion segment(length, color). Die Funktion zeichnet ein einzelnes Segment, das auf beiden Seiten spitz ausläuft – siehe Bild.

Das Argument length gibt die Länge des Segments von Spitz zu Spitz an. Damit genau diese Länge zustande kommt, musst du etwas rechnen. Eventuell brauchst du die Funktion sqrt und hierzu das Math-Modul (import math).
Das Argument color gibt die Farbe des Segments an.
Starte bei der einen Spitze und gehe davon aus, dass die Turtle in Richtung der anderen Spitze schaut, siehe Bild.

Schritt 2 – Codes definieren

Im Bild rechts sind die 7 Segmente mit den Buchstaben A bis G bezeichnet. Den Dezimalpunkt lassen wir ausser Acht. Für die Ziffern 0 und 4 müssten die Segmente gemäss folgender Tabelle leuchten:

Ziffer	A	B	C	D	E	F	G	Binär-String
0	1	1	1	1	1	1	0	`„1111110“`
4	0	1	1	0	0	1	1	`„0110011“`

Erstelle eine Liste binary_strings[], die für jede Ziffer 0…9 den richtigen Binär-String enthält.

Schritt 3 – Zahl mit 7 Segmenten anzeigen

Erstelle eine Funktion seven_seg(number). Die Funktion zeichnet die 7 Segmente A bis G an den richtigen Positionen und in richtiger Farbe:

Verwende die bereits erstellte Funktion segment.
Speichere für jedes Segment die x-Positionen, die y-Positionen und die Richtungen (heading) in Listen.
Das Argument number gibt an, welche Ziffer dargestellt werden soll. Verwende deine Liste binary_strings[], um für jedes Segment zu entscheiden, ob es rot oder grau „gainsboro“ sein soll.
Teste deine Funktion mit einem Programm, dass die Zahlen von 0 bis 9 im Sekundentakt (delay(1000)) hochzählt.

Zusatzaufgaben

Programmiere eine zweistellige Anzeige, die von 0 bis 99 zählen kann.
Programmiere eine digitale Uhr, die die aktuelle Zeit in Stunden, Minuten und Sekunden (von Doppelpunkten getrennt) anzeigt.

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

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

Variante 1

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

Variante 2

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

Auftrag 3

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)

Auftrag 4

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

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.

Lösungen zu Aufgaben NA:

NA1

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

NA2

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

NA3 – Schritt 1

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

NA3 – Schritt 2

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

NA4

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

Lösungen zu Aufgaben NB:

NB1

def chf_in_nok(chf):
    return chf * 12.57
 
print(chf_in_nok(3))

NB2

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

NB3

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

NB4

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

NB5

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

NB6

def ist_gerade(n):
    if n % 2 == 0:
        return True
    return False
 
print(ist_gerade(4))
print(ist_gerade(5))

NB7

def pizza_lieferung(personen):
    if personen * 12 >= 50:
        return personen * 12
    else:
        return personen * 12 + 20
 
print(pizza_lieferung(4))
print(pizza_lieferung(5))

NB8

Lösungen zu Aufgaben NC:

NC1

from gturtle import*
karl = Turtle()
 
def hexagon(): 
    side_count = 0
    while side_count < 6:
        karl.forward(50)
        karl.right(60)
        side_count = side_count + 1
 
hex_count = 0 
while hex_count < 6:
    hexagon()
    karl.forward(50)
    karl.left(60)
    hex_count = hex_count + 1

NC2

import random
from gturtle import * 
flori = Turtle()
 
def punkte(min, max, colors):
    i = 0
    anz = random.randint(min, max)
    while i < anz:
        xpos = random.randint(-250,250)
        ypos = random.randint(-100,100)
        flori.setPenColor(colors[random.randint(0,len(colors)-1)])
        flori.setPos(xpos, ypos)
        flori.dot(20)
        i = i + 1
    return i
 
farben = ["red", "blue", "green", "orange"]
 
anz_punkte = punkte(5, 40, farben)
print(f"Es wurden {anz_punkte} Punkte gezeichnet.")

NC3

import random
from gturtle import *
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)
 
def kleeblatt3(radius):
    i = 0
    while i < 3:
        herzblatt(radius, "green")
        tommy.right(120)
        i = i + 1
 
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

NC3 Zusatzaufgabe

import random
import math
from gturtle import *
tommy = Turtle()
tommy.hideTurtle()
tommy.clear("lightpink")
 
def herzblatt2(seite, farbe1, farbe2):
    tommy.setFillColor(farbe1)
    tommy.startPath()
    tommy.forward(seite)
    tommy.rightArc(seite/2,180)
    tommy.right(45)
    tommy.forward(seite*math.sqrt(2))
    tommy.fillPath()
    tommy.setFillColor(farbe2)
    tommy.startPath()
    tommy.left(135)
    tommy.forward(seite)
    tommy.leftArc(seite/2,180)
    tommy.left(45)
    tommy.forward(seite*math.sqrt(2))
    tommy.fillPath()
 
def kleeblatt3(radius):
    i = 0
    while i < 3:
        herzblatt2(radius, "forestgreen", "green")
        tommy.right(15)
        i = i + 1  
 
def kleeblatt4(radius):
    i = 0
    while i < 4:
        herzblatt2(radius, "darkgreen", "007200")
        tommy.right(45)
        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

NC4

Variante mit While-Schleife:

def text_reverse(text):
    new_text = ""
    i = len(text)-1
    while i >= 0:
        new_text = new_text + text[i]
        i = i-1
    return new_text
 
print(text_reverse("Roti Rösli im Garte"))

Kurze Variante mit Slice-Syntax (optional):

def text_reverse(text):
    return text[::-1]
 
print(text_reverse("Roti Rösli im Garte"))

NC5

def replace_spaces(text, char):
    i = 0
    new_text = ""
    while i < len(text):
        if text[i] == ' ':
            new_text = new_text + char
        else:
            new_text = new_text + text[i]
        i = i + 1
    return new_text
 
print(replace_spaces("Roti Rösli im Garte", '-'))

NC6

def word_list(text):
    words = []
    word = ""
    i = 0
    while i < len(text):
        if text[i] == ' ': # Leerzeichen
            words.append(word)
            word = ""
        else:
            word = word + text[i]
        i = i + 1
    words.append(word)
    return words
 
def words_reverse(text): 
    words = word_list(text)
    new_text = ""
    i = len(words) - 1
    while i >= 0:
        new_text = new_text + words[i] + " "
        i = i - 1
    return new_text
 
print(words_reverse("Roti Rösli im Garte"))

Lösungen zu Aufgaben O:

O1

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

O2

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

O3

from gturtle import * 
leonardo = Turtle()
 
def fibonacci(n):
    fibs = []
    s1 = 0
    s2 = 1
    i = 0
    while i < n:
        fibs.append(s1)
        s = s1 + s2
        s1 = s2
        s2 = s
        i = i + 1
    return fibs
 
def viertelkreis(radius, farbe):
    leonardo.setFillColor(farbe)
    leonardo.startPath()
    leonardo.rightArc(radius, 90)
    leonardo.right(90)
    leonardo.forward(radius)
    leonardo.fillPath()
    leonardo.right(180)
    leonardo.forward(radius)
    leonardo.right(90)
 
def fibo_spirale(n):
    fibos = fibonacci(n)
    i = 0
    while i < len(fibos):
        radius = fibos[i] * 10
        if i % 2 == 0:
            viertelkreis(radius,"red")
        else:
            viertelkreis(radius,"blue")
        i = i + 1
 
def fibo_spirale2(n, colors):
    fibos = fibonacci(n)
    i = 0
    while i < len(fibos):
        radius = fibos[i] * 10
        viertelkreis(radius, colors[i % len(colors)])
        i = i + 1
 
leonardo.right(90)        
farben = ["crimson", "orange", "maroon", "gold"]
fibo_spirale2(9, farben)

O4

import math
from gturtle import * 
 
carl = Turtle()
carl.hideTurtle()
 
def segment(length, color):
    l1 = length * 0.8
    l2 = (length - l1)/2
    side = l2 * math.sqrt(2)
    carl.setFillColor(color)
    carl.startPath()
    carl.right(45)
    repeat 2:
        carl.forward(side)
        carl.left(45)
        carl.forward(l1)
        carl.left(45)
        carl.forward(side)
        carl.left(90)
    carl.fillPath()
    carl.left(45)
 
def seven_seg(number):
    segment_codes = ['1111110', # 0
                     '0110000', 
                     '1101101', 
                     '1111001', 
                     '0110011', 
                     '1011011', 
                     '1011111', 
                     '1110000', 
                     '1111111', 
                     '1111011'] # 9
 
    xpositions = [0, 100, 100, 100, 0, 0, 0]
    ypositions = [0, 0, -100, -200, -200, -100, -100]
    headings = [90, 180, 180, 270, 0, 0, 90]
 
    i = 0
    for s in segment_codes[number]:
        carl.setPos(xpositions[i], ypositions[i])
        carl.setHeading(headings[i])
        if s == '0':
            segment(100, "gainsboro")
        else:
            segment(100, "red")
        i = i + 1
 
i = 0
while i <= 9:
    seven_seg(i)
    i = i + 1
    delay(1000)

¹⁾

„crimson“

²⁾

Der Rückgabewert der Funktion schnitt wird der Funktion print als Argument übergeben