====== Programmieren Teil 4 – Funktionen ======
* Dieses Seite ist die Fortsetzung von [[gf_informatik:programmieren_iii_gra|]].
* Weiter zu [[gf_informatik:programmieren_v_gra|]].
++++Lernziele:|
- Ich beherrsche die in Teil 1 und 2 gelernten Grundlagen in python (Turtlegraphics, Variablen, while-Schleife, Verzweigungen, Vergleichsoperatoren, mathematische Operatoren, f-Strings, Funktionen ''print'' und ''input'', nie repeat verwenden, clever und kompakt programmieren).
- Ich beherrsche den Umgang mit Listen, wie in Teil 3 gelernt:
* Listen korrekt erstellen – leer oder mit Zahlen oder mit Texten drin.
* Mit einer while-Schleife alle Elemente einer Liste durchgehen, sie auslesen/ausgeben oder mit einer if-Verzweigung abfragen und evtl. verändern oder entfernen.
* Die Listen-Funktionen ''pop'' und ''append'' richtig verwenden.
* Mit ''in'' fragen, ob ein bestimmtes Element in einer Liste vorkommt.
* Listen analysieren (z.B. Mittelwert ermitteln) oder verändern (z.B. bestimmte Elemente ersetzen etc.).
- Ich kann Funktionen mit und ohne Argumente definieren.
- Ich kann Funktionen mit und ohne Rückgabewerte definieren.
- Ich kann Funktoinen korrekt und sinnvoll aufrufen. Dabei achte ich darauf:
- ...welche Argumente der Funktion übergeben werden und
- ...was die Funktion zurückgibt.
- Ich verstehe die Begriffe **Argument**, **Rückgabewert**, **Definition** und **Aufruf**.
- Ich kann die logischen Operatoren ''and'', ''or'' und ''not'' korrekt verwenden.
- Ich kann Mudule wie ''random'' oder ''math'' importieren und Funktionen daraus wie ''randint'' oder ''sqrt'' korrekt verwenden.
- Ich beherrsche einfache String-Operationen (Texte erstellen, Texte zusammenfügen, auf bestimmte Buchstaben zugreifen).
- Ich kann die Buchstaben eines Texts mithilfe einer while-Schleife durchgehen, sie auslesen/ausgeben oder mit einer if-Verzweigung abfragen.
++++
===== - 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)?
===== - 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)
{{:gf_informatik:programmieren_iv_gra:pasted:20250423-122049.png?200}}
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()
{{:gf_informatik:programmieren_iv_gra:pasted:20250423-122800.png?200}}
**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 ==
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:
{{:gf_informatik:programmieren_iv_gra:pasted:20250423-130345.png?180}}
=== 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")
{{:gf_informatik:programmieren_iv_gra:pasted:20250423-145320.png?200}}
== 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(("crimson")) Punkte in den Grössen 20, 30, 40, 30, siehe Bild.
{{:gf_informatik:programmieren_iv_gra:pasted:20250423-181230.png?200}}
=== 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)).
def schnitt(zahl1, zahl2):
summe = zahl1 + zahl2
return summe/2
print(schnitt(4, 5))
**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).
* [[.:funktionen:aufgaben_a|]]
* [[.:funktionen:aufgaben_b|]]
* [[.:funktionen:aufgaben_c|]]
* [[.:funktionen:aufgaben_d|]]
===== - Lösungen zu den Aufträgen =====
++++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.
++++