Prozeduren als wiederverwendbare Bausteine

In diesem Artikel illustrieren wir nochmals den Punkt, wie wir Prozeduren einsetzen können um eigene, wiederverwendbare Abstraktionen zu definieren. Dabei nutzen wir wieder Turtlegrafik.

Hinweis: Wir sprechen im folgenden immer über Prozeduren. Alle Betrachtungen gelten aber genauso für Funktionen.

Zeichnen von geometrischen Figuren​

Angenommen wir bekommen die Aufgabe, mithilfe von Turtlegrafik verschiedene Geometrische Figuren, wie zum Beispiel ein Quadrat, ein Rechteck und ein Dreieck, zu zeichnen. Unsere Lösung könnte wie folgt aussehen:

# Zeichne ein Quadrat
i = 0
while i < 4:
  forward(100)
  right(90)
  i = i + 1

# Zeichne ein Reckteck
forward(100)
left(90)
forward(50)
left(90)
forward(100)
left(90)
forward(50)
left(90)

# Zeichne Dreieck
i = 0
while i < 3:
    forward(100)
    left(120)
    i = i + 1

Diese Lösung funktioniert, ist aber nicht sehr elegant. Es gibt verschiedene Probleme:

1. Ohne die Kommentare wäre es nicht direkt ersichtlich, was die Codezeilen machen.
2. Die Position von jeder geometrischen Figur ist fix
3. Wenn wir die Zeichnung um eine weitere geometrische Figur erweitern wollen, müssen wir Code kopieren.

Prozeduren als flexible Bausteine​

Wir können dieses Programm verbessern, indem wir Prozeduren einsetzen. Jede geometrische Figur wird durch eine Prozedur repräsentiert. Damit wir flexibel sind, führen wir auch gleich Parameter ein.

Wir beginnen mit dem Rechteck. Als Parameter geben wir die Höhe und Breite an. Damit wir dies flexibel an verschiedenen Positionen platzieren können, geben wir auch gleich die Position mit, an der das Rechteck gezeichnet werden soll.

def draw_rectangle(width, height, posx, posy):
    penup()
    home()
    forward(posx)
    left(90)
    forward(posy)
    right(90)
    pendown()

    forward(width)
    left(90)
    forward(height)
    left(90)
    forward(width)
    left(90)
    forward(height)
    left(90)

Genauso Verfahren wir mit dem Dreieck

def draw_triangle(length, posx, posy):
    penup()
    home()
    forward(posx)
    left(90)
    forward(posy)
    right(90)
    pendown()


    i = 0
    while i < 3:
        forward(length)
        left(120)

Das Zeichnen des Quadrats ist nun eine triviale Prozedur, die einfach die Prozedur draw_rectangle wiederverwendet:

def draw_square(length, posx, posy):
    draw_rectangle(length, length, posx, posy)

Nun können wir uns unsere Zeichnung viel einfacher erstellen:

draw_square(100, 100, 0, 0)
draw_rectangle(100, 50, 100, 100)
draw_triangle(100, 200, 100)

Die Vorteile sind offensichtlich. Der Code ist nun viel übersichtlicher und flexibler. Die Codeteile die zusammengehören sind nun alle zusammengefasst. Das Kommentieren des Codes erübrigt sich, da bereits aus dem Namen der Prozedur hervorgeht, was gemacht wird.

Der vielleicht wichtigste Punkte ist aber, dass wir uns Bausteine geschaffen haben, die wir nach Bedarf flexibel wiederverwenden können. Wenn wir zum Beispiel die Zeichung um ein Rechteck erweitern wollen, müssen wir nur die Prozedur draw_rectangle ein zweites Mal aufrufen.

Wenn wir uns den Code genau anschauen, dann fällt uns auf, dass das setzen der Position in beiden Fällen, also beim Rechteck und beim Dreieck, genau gleich ist. Solche Codeduplikationen sind meist ein Zeichen dafür, dass wir nochmals eine wiederverwendbaren Baustein gefunden haben.

Experiment​

• Führen Sie eine Prozedur set_position ein, welche das setzen der Turtleposition übernimmt und verwenden diese in den Prozeduren draw_rectangle und des draw_triangle.

Fragen und Kommentare​

Haben Sie Fragen oder Kommentare zu diesem Artikel? Nutzen Sie das Forum und helfen Sie sich und Ihren Mitstudierenden dieses Thema besser zu verstehen.