Jython

4. Funktionen

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

Beispiel 1: Eine Ampel in mehreren Farben blinken lassen
Ein "Flashvorgang" 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. Es ist zweckmässig, den Flashvorgang in einer Funktion (einem benannten Block) zusammenzufassen und diese Funktion jeweils mit einer anderen Farbe aufzurufen.

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

# Gp4a.py
from gpanel import *

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

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



Erklärungen zum Programmcode:

def flash(c): Funktionsdefinition. 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. Meist wählt man als Namen ein aussagekräftiges Wort oder eine offensichtliche Abkürzung dafür.
flash("red"): Funktionsaufruf. Ohne einen Funktionsaufruf wird die Funktion nie ausgeführt.


Beispiel 2: Den Befehlssatz erweitern
Das Modul GPanel enthält bereits sehr viele vordefinierte Funktionen. Mit selbst definierten Funktionen kann man diesen Befehlssatz beliebig erweitern.

In diesem Beispiel wird eine Funktion star(x, y) definiert, die unter der Verwendung von zwei gefüllten gleichseitigen Dreiecken mit dem gleichen Mittelpunkt x, y einen Stern zeichnet. Im Hauptprogramm wird diese Funktion dann mehrmals aufgerufen.

# 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
 

Erklärungen zum Programmcode:

fillTriangle(): Ausgehend vom Mittelpunkt (x, y) des Umkreises können mit dem Satz von Pythagoras die Koordinaten der Eckpunkte der gleichseitigen Dreiecke berechnet werden. Hier wird mit dem Umkreisradius 1 gerechnet.
star(2, 2) Funktionsaufruf. Zeichnet einen Stern an der Position (2, 2)


Beispiel 3
: 30 zufällige Sternen auf blauem Hintergrund (Sternenhimmel) zeichnen
Die Funktion star() wird unverändert übernommen, aber die Positionen zufällig gewählt.

# 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
 

Erklärungen zum Programmcode:

bgColor("darkblue"): setzt die Hintergrundfarbe des Grafikfensters auf dunkelblau


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). Es kann bereits an einfachen Beispielen geübt werden. 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, definiert man die Funktion flower(), die eine einzelne Blume zeichnet. Diese besteht aus einem geradlinigen Stiel und  einer Blüte, die in bloom() definiert ist. Schliesslich definiert man mit garden(n)  n Blumen an zufälliger x-Position.

# 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
 

 


Aufgaben: Serie 4

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.