4. Funktionen

 

 

DU LERNST HIER...
 

Funktionen sind benannte Programmblöcke, mit welchen du Programme besser strukturieren kannst. Die Verwendung von Funktionen ist von grosser Wichtigkeit, denn du vermeidest dadurch, dass du den gleichen Code mehrmals im Programm hinschreiben musst (Codeduplikation)  und kannst damit Probleme in kleinere, einfachere Teilprobleme zerlegen.

 

 

MUSTERBEISPIELE
 


Beispiel 1: Eine Ampel in mehreren Farben blinken lassen

Ein "Blinkvorgang" mit der Farbe c besteht aus folgenden Aktionen: die Farbe wählen, den gefüllten Kreis mit dieser Farbe zeichnen, 500 Millisekunden warten, die weisse Farbe wählen, den gefüllten Kreis mit weissen Farbe überzeichnen (und damit löschen) und 500 Millisekunden warten. Den Blinkvorgang kannst du in einer Funktion (einem benannten Block) zusammenzufassen und diese Funktion jeweils mit einer anderen Farbe aufrufen.

Die Funktionsdefinition beginnt mit dem Keyword def. Dann folgen der Name, eine Parameterklammer und ein Doppelpunkt. Die Klammer kann Parameter enthalten (hier c), die in der Funktion gebraucht werden. Falls man keine Parameter benötigt, ist die Klammer leer. Die Befehle im Funktionskörper bilden einen Programmblock und müssen daher eingerückt sein.

Die Funktionsdefinitionen befinden sich oben im Programm, meist unmittelbar nach den Importzeilen. Im Hauptprogramm wird die Funktion dreimal aufgerufen und zwar mit den Parameterwerten "red", "yellow" und "green" .

Programm:  

# Gp4a.py
from gpanel import *

def flash(c):
    setColor(c)
    fillCircle(3)
    delay(500)
    setColor("white")
    fillCircle(3.2)
    delay(500)

makeGPanel(-10, 10, -10, 10)
repeat 10:
    flash("red")
    flash("yellow")
    flash("green")
► In Zwischenablage kopieren		  




Beispiel 2: Den Befehlssatz erweitern

Das Modul GPanel enthält bereits viele vordefinierte Funktionen. Mit selbst definierten Funktionen kannst du diesen Befehlssatz beliebig erweitern. In diesem Beispiel definierst du eine Funktion star(x, y) die unter der Verwendung von zwei gefüllten gleichseitigen Dreiecken mit dem gleichen Mittelpunkt x, y einen Stern zeichnet. Im Hauptprogramm rufst du diese Funktion mehrmals auf.

Programm:  

# Gp4b.py
from gpanel import *

def star(x, y):
    fillTriangle(x - 0.86, y - 0.5, 
                 x + 0.86, y - 0.5, x, y + 1)
    fillTriangle(x - 0.86, y + 0.5, 
                 x + 0.86, y + 0.5, x, y - 1)
    
makeGPanel(0, 10, 0, 10)
setColor("red")
star(2, 2)
star(5, 7) 
star(7, 4)
► In Zwischenablage kopieren		  

 

Beispiel 3: Zufällige Sternen auf blauem Hintergrund (Sternenhimmel) zeichnen

Die Funktion star() wird unverändert übernommen, aber die Positionen zufällig gewählt. Mit bgColor("darkblue") kannst du die Hintergrundfarbe des Grafikfensters auf dunkelblau setzen.

Programm:  

# Gp4c.py
from gpanel import *
from random import randint

def star(x, y):
    fillTriangle(x - 0.86, y - 0.5, 
                 x + 0.86, y - 0.5, x, y + 1)
    fillTriangle(x - 0.86, y + 0.5, 
                 x + 0.86, y + 0.5, x, y - 1)
    
makeGPanel(0, 25, 0, 25)
bgColor("darkblue")
setColor("yellow")
repeat 30:
    x = randint(3, 22)
    y = randint(3, 22) 
    star(x, y)
► In Zwischenablage kopieren		  

 

Beispiel 4: Probleme schrittweise lösen

An diesem einfachen Beispiel wird exemplarisch gezeigt, wie man Probleme schrittweise löst. Das Zerlegen eines komplexen Problems in einfache Teilprobleme ist ein wichtiges Programmierkonzept (auch Strukturiertes Programmieren genannt). Du kannst es an einfachen Beispielen üben. Dabei spielen Funktionen eine zentrale Rolle, darum nennt man das Konzept auch Funktionales bzw. Prozedurales Programmieren. (In Python sind Funktionen und Prozeduren das gleiche.)

Um einen Blumengarten zu erstellen, was eine relative komplexe Aufgabe ist, definierst du die Funktion flower(), die eine einzelne Blume zeichnet. Diese besteht aus einem geradlinigen Stiel und  einer Blüte, die du mit der Funktion bloom() definierst. Schliesslich definierst du die Funktion garden(n) , die n Blumen an zufälliger x-Position zeichnet.

Programm:  

# Gp4d.py
from gpanel import *
from random import randint

def bloom():
    setColor("magenta")
    fillCircle(2)
    setColor("yellow")
    fillCircle(1)

def flower(x):
    pos(x, 0)
    lineWidth(3)
    setColor("green")
    line(x, 0, x, 4)
    pos(x, 6)
    bloom()
    
def garden(n):
    repeat n:
        x = randint(0, 30)
        flower(x)    

makeGPanel(-3, 32, -10, 25)
garden(10)
► In Zwischenablage kopieren		  

 

 

MERKE DIR...
 

Mit Funktionen kannst du Programme besser strukturieren und den Befehlssatz erweitern. Der Funktionsnamen wird mit einem kleinen Anfangsbuchstaben geschrieben und kann frei gewählt werden. Nicht erlaubt sind Schlüsselwörter und Wörter mit Umlauten. Ohne einen Funktionsaufruf wird die Funktion nie ausgeführt.

 

 

ZUM SELBST LÖSEN
 

1)


Je 50 rote, blaue, grüne, gelbe und violette farbige Kreise sollen an zufällig gewählten Positionen erscheinen. Definiere dazu eine Funktion colorCircle(c) mit folgenden Aktionen:
- setzt die Farbe auf Color c
- setzt die Position auf zufällig gewählte Koordinaten im Bereich 0 bis 100
- zeichne einen kleinen gefüllten Kreis

Im Hauptprogramm verwendest du eine repeat 50: -Schleife und rufst in der Schleife die Funktion colorCircle() mit den Parametern "red", "yellow" usw. auf.

  

 

2)
Definiere eine Funktion bird(x, y), die an der Position x, y einen vogelartigen Linienzug zeichnet. Dabei verwendest du im GPanel mit den Koordinaten (0, 20, 0, 20) die zwei Kreisbogenfunktionen arc(2, 30, 120) und arc(2, 150, -120).		  

 

3)

Definiere eine Funktion snowman(x), die an der Position (x, 0) einen weissen Schneemann zeichnet.

Im Hauptprogramm wählst du einen blauen Hintergrund und rufst die Funktion mehrmals an verschiedenen Positionen auf.