Python mit der Schildkröte?

Nach der Entscheidung für Python als Programmiersprache im Informatikunterricht der Mittelstufe zum Sommer 2008 war für mich unstrittig, dass die klassische „EVA-Terminal-Programmierung“ um graphische Darstellung und zeitgemäße Möglichkeiten der Anwenderinteraktion erweitert werden mussten. Bloß wie?

Die Turtle-Grafik-Idee war aus meiner Sicht zwar geeignet, das damalige Python-Modul turtle war aber viel zu schwachbrüstig und unattraktiv. Das hatte vor mir auch schon Gregor Lingl erkannt und daraufhin das Modul xturtle entwickelt. Im Herbst 2008 wurde dieses – nun unter dem Namen turtle – in die offizielle Python-Version 2.6 aufgenommen und ist seitdem fester Bestandteil der Standardbibliothek von Python.

Die neue Schildkröte

Das Modul xturtle bzw. das „neue“ Modul turtle hat – abgesehen vom Grundprinzip und der Abwärtskompatibilität – wenig gemein mit dem alten turtle-Modul. Es ist erheblich umfangreicher und ebenso auch erheblich leistungsfähiger.

Während das alte turtle-Modul aus weniger als 1000 Zeilen Code besteht, kommt das xturtle-Modul auf 3000 Zeilen und als turtle-Modul in der aktuellen Python 3.x-Implementierung sogar auf deutlich mehr als 4000 Zeilen (jeweils mit einem Anteil von schätzungsweise 40-50% an Kommentarzeilen).

Die Schildkröte im Einsatz

Das folgende Beispiel zeigt die Funktionsweise und den Aufbau eines einfachen turtle-Programms, nicht die Leistungsfähigkeit des Moduls. Dazu genügt ein Blick in die vollständige Referenz des turtle-Moduls als Bestandteil der offiziellen Dokumention der Standardbibliothek von Python. Ebenso empfehlenswert ist das (leider schon einige Jahre alte) Buch Python 4 Kids von Gregor Lingl (das Nachfolgewerk von Hans-Georg Schumann mit gleichem Titel aus demselben Verlag möchte ich hingegen ausdrücklich nicht empfehlen).

Beispiel (Python 3 mit turtle):

from turtle import Screen,RawTurtle

area = Screen()
pen = RawTurtle(area)
area.colormode(255)
area.bgcolor("#444")
pen.pensize(4)
for k in range(60,0,-1):
    pen.pencolor(4*k+10,255-2*k,4*k)
    pen.forward(200)
    pen.left(157)
    pen.penup()
    pen.backward(40)
    pen.pendown()
    pen.right(28)
pen.penup()
pen.color("lime")
pen.goto(122,49)
pen.dot(50)
area.mainloop()

Den Ablauf des Programms kann man sich im Ausgabefenster ansehen:

Die Schwächen der Schildkröte

Ich habe für die Umsetzung bewusst die objektorientierte Darstellung des xturtle-Moduls gewählt, weil daran deutlicher wird, was mir nicht gefällt. Alternativ (und eher üblich) kann statt mit Objekten und Methoden auch nur mit Funktionen gearbeitet werden.

Im Grunde sind es letztlich drei Aspekte, die mir nicht gefallen und die dazu geführt haben, das turtle-Modul nicht einsetzen zu wollen:

  1. Die Nutzung der Grundfunktionalität – Bewegen und Zeichnen – ist zu umständlich.
    Getrennte Befehle für Vorwärts- und Rückwärtsbewegung ebenso wie für Links- und Rechtsdrehung sind nicht nur überflüssig, sondern verkomplizieren manche Problemlösung und verlängern den Quelltext. Auch die penup()- und pendown()-Methoden bzw. -Funktionen empfinde ich als zu umständlich: Man muss quasi Buch führen über die jeweils aktuelle Stiftposition (oben oder unten). Gerade bei längeren Programmen ist das lästig und fehleranfällig.
  2. Zwischen Methoden (Fähigkeiten) und Datenattributen (Eigenschaften) wird nicht konsequent unterschieden.
    An diesem Punkt werden die Kriterien für eine „semantische Programmierung“ nicht erfüllt, und das halte ich gerade im Hinblick auf den vorgesehen Einsatzzweck für unglücklich (und vermeidbar). Die Farbe – sei es der Hintergrund oder die Zeichenfarbe – sind definitiv keine Fähigkeiten von Screen oder Turtle, sondern Eigenschaften. Dementsprechend sollten sie als Datenattribute und nicht als Methoden realisiert werden.
  3. Die Implementation ist unaufgeräumt und unnötig umständlich.
    Das kann man am Beispiel nicht erkennen, sondern nur durch Analyse des turtle-Quelltextes. Und da kann ich sagen: Halb so viel Quelltext genügt, um die gleiche Funktionalität sauberer zu implementieren.

Python ohne Schildkröte

Die genannten Kritikpunkte an xturtle waren für mich ausreichend, um dieses Modul nicht im Unterricht einsetzen zu wollen, obwohl mir die Grundidee der turtle-Grafik nach wie für den Informatikunterricht geeignet und tragfähig erschien. Eine Alternative gab es nicht. Also bin ich 2008 selbst tätig geworden und habe ein turtle-Grafik-Modul für Python entwickelt, das die beschriebenen Nachteile von (x)turtle nicht hat.

Python mit dem Frosch

Die Schildkröte war schon vergeben, ein anderes Tierchen musste her: Ein Frosch passt gut, denn der kann – anders als die Schildkröte – von einem Ort zum anderen „springen“ (= Bewegen ohne Zeichnen) oder „schwimmen“ (= Bewegen mit Zeichnen).
Damit hatte das frog-Modul seinen Namen.

Froschtheorie

Anders als Gregor Lingl, der bei der Entwicklung von xturtle im HInblick auf die Übernahme in die Python-Standardbibliothek auf Abwärtskompatiblität zum (alten) turtle-Modul mit allen seinen Unzulänglichkeiten achten musste, hatte ich diesbezüglich alle Freiheiten. Die habe ich genutzt, um das frog-Modul durchgängig objektorientiert zu gestalten. Das ist nur konsequent, denn ein Frosch ist nun offensichtlich ein Objekt mit bestimmten Eigenschaften und Fähigkeiten; auch der Teich („Pool“) als Lebensraum des Frosches hat gewisse Eigenschaften. Bei der Implementation war mir Klarheit und Stringenz wichtig, und so ist der Umfang des Quelltextes weniger als halb so groß wie der von (x)turtle – bei vergleichbarem Funktionsumfang.

Neben der Grundfunktionalität – Bewegen und Zeichnen – war mir vor allem ein für die Schüler verständlicher und klarer Zugang zur Ereignisbehandlung wichtig. So können z.B. Frosch-Objekte darauf „lauschen“, ob sie mit der Maus angeklickt werden und dann gemäß den Wünschen des Programmierers reagieren. Wie das in der Praxis aussehen kann, zeigt das zweite der beiden folgenden Beispiele.

Froschpraxis

Zunächst zeige ich das frog-Äquivalent zum obigen turtle-Code. Der Quelltext ist nicht nur um einige Zeilen kürzer, sondern zeigt auch wie meine Lösung der oben formulierten Kritik am turtle-Modul konkret aussieht: Es gibt zwei Methoden für die Bewegung, die entweder mit einer Zeichenaktion verbunden ist (move) oder eben nicht (jump). Zu beiden Methoden gibt es eine Entsprechung zur absoluten Positionierung des Froschs (moveto bzw. jumpto). Für (relative) Drehungen wird nur eine Methode benötigt (turn), die je nach Vorzeichen des übergebenen Winkels eine Links- bzw. Rechtsdrehung bewirkt; auch hier gibt es mit turnto eine Entsprechung zur absoluten Winkelausrichtung.

from frog import Pool,Frog

area = Pool()
pen = Frog(area)
area.bgcolor = "#444"
pen.width = 4
for k in range(60,0,-1):
    pen.color = 4*k+10,255-2*k,4*k
    pen.move(200)
    pen.turn(157)	
    pen.jump(-40)	
    pen.turn(-28)
pen.color = "lime"
pen.jumpto(122,49)
pen.dot(50)
area.ready()

Das nächste Beispiel demonstriert speziell die Ereignisbehandlung und ihre einfache Zugänglichkeit.

from frog import Pool,Frog
from random import randrange as r

def draw(event):
    kermit.jumpto(90,10)
    kermit.turnto(90)
    kermit.bodycolor = "lime"   
    for k in range(18):
        kermit.turn(20)
        kermit.jump(35)
        kermit.color=r(256),r(256),r(256)
        kermit.dot(r(4,30))
    kermit.home()
    kermit.bodycolor = "forestgreen"
    kermit.color = "black"

pool = Pool()
pool.bgcolor = "#2e86c1"
kermit = Frog(pool)
kermit.shape = "frog"
kermit.bodycolor = "forestgreen"
kermit.visible = True
kermit.listen("<Button>",draw)
pool.ready()

Hier kann man sich den Programmablauf ansehen. Dazu öffnet sich ein neues Browserfenster. Der Frosch reagiert auf Mausklick und legt dann los ...

Einsatz im Unterricht

Passend zu den Möglichkeiten des frog-Moduls habe ich zwei Python-Lernkurse entwickelt, die in insgesamt 23 Lektonen in die Programmierung einführen. Der erste im Unterricht eingesetzt Lernkurs beginnt mit einigen Lektionen klassischer Programmierung („EVA im Terminal“). Erst danach, nachdem alle wesentlichen Datentypen und Kontrollstrukturen behandelt wurden, wird das frog-Modul mit hinzu genommen, um in die grafische Programmierung einzusteigen.

Der zweite, später entwickelte Lernkurs setzt von Beginn an auf das frog-Modul und kombiniert die grafische Programmierung mit dem Erlernen der wesentlichen Datentypen und Kontrollstrukturen.

Erfahrungen

Nach 10 Jahren Einsatz von Python als Lernsprache in Kombination mit dem frog-Modul kann ich guten Gewissens sagen: Es ist ein Weg zur Programmierung, der sich bewährt hat. Dass ich dennoch nach den 10 Jahren von Python zu JavaScript als Lernsprache gewechselt bin, hatte keine sprachimmanenten Gründe – die Begründung für den Erstsprachenwechsel habe ich an andere Stelle ausgeführt.

Der erste Lernkurs, bei dessen Entwicklung ich wahrscheinlich noch dem zuvor praktizierten Konzept bei der Verwendung von Pascal als Erstsprache verhaftet war, hat zwar funktioniert, aber die Lernstrecke bis zur Einführung des frog-Moduls und der attraktiveren Grafikprogrammierung war doch für manch einen recht lang. Das hat mich dazu bewogen, den Lernkurs komplett umzuarbeiten in der oben beschriebenen Form. Das hat sich aus meiner Sicht bewährt. Die Motivation zum Lernen einer (Programmier-)Sprache ist dadurch auch bei denjenigen mit etwas weniger Affinität zur Programmierung deutlich höher.

Fazit

Python mit dem frog-Modul ist meiner Ansicht nach hervorragend zum Erwerb einer Programmiersprache in der Mittelstufe geeignet. Das frog-Modul ist durch zahlreiche Einsätze im Unterricht ausreichend gut getestet, stabil und offensichtlich weitestgehend fehlerfrei. Gemeinsam mit dem Lernkurs liegt damit ein komplettes Konzept für das Erlernen der Programmierung mit Python vor.

Im Hinblick auf die künftige Nutzung wird man sehen müssen, inwieweit Schüler der Mittelstufe bzw. deren Haushalte überhaupt noch über einen PC oder ein Notebook verfügen. Sollte die Entwicklung dahin gehen, dass mehr und mehr Tätigkeiten sich von diesen Endgeräten auf Smartphone und Tablet verlagern, dann wären das keine guten Voraussetzungen für dieses Konzept.

Aktuell (Anfang 2021) gibt es noch keine offizielle Python-Distribution der Python Software Foundation für mobile Betriebssysteme (Android, iOS). Es gibt Adaptionen von Python für Android, und mit dem GUI-Toolkit Kivy lassen sich mit Python Anwendungen entwickeln, die auch auf mobilen Betriebssysten laufen. Das Ganze läuft aber noch lange nicht „out-of-the-box“ – Installation und Konfiguration auf einem mobilen Betriebssystem sind noch viel zu knifflig. Das sieht in einigen Jahren vielleicht anders aus. Man wird sehen.

The power of the frog

Die Beispiel oben zeigen zwar, wie einfach sich mit dem frog-Modul arbeiten lässt, aber nicht, wie leistungsfähig es ist. Das frog-Modul lebt von seinen Fröschen, die schreiben, lesen, singen, schwimmen, springen, tauchen, sich in beliebige andere Figuren verwandeln und weitere Kunststückchen können. Mit frog kann man komplexe, rekursive Grafiken ebenso entwickeln wie ereignisgesteuerte Anwendungen, graphische Animationen und – wichtig, wichtig! – Spiele.

Zum Umfang des frog-Pakets gehört ein Demoprogramm, das einige dieser Möglichkeiten in Ansätzen zeigt. Was – theoretisch – möglich ist, zeigt das Programm TetraFrog.
Damit meine Schüler ihre Ideen selbst entwickeln, zeige ich den Quelltext des Programms an dieser Stelle natürlich nicht. Er umfasst rund 350 Zeilen und ist objektorientiert aufgebaut. Die Steuerung erfolgt mittels Pfeiltasten und Leertaste.

Ein weiteres Beispiel für die Leistungs- und Integrationsfähigkeit des frog-Moduls ist der Frosch für Kinder – eine auf der Basis des frog-Moduls konzipierte einfache Befehlssprache mit integrierter Entwicklungsumgebung.

Frog: Download

Das frog-Modul für Python 3 steht hier zum Download in der aktuellen Fassung zur Verfügung. Das Download-Paket beeinhaltet außer dem eigentlichen Modul auch ein Demoprogramm und eine ausführliche, referenz­artige Dokumentation mit weiteren Beispielen. Das frog-Modul kann ohne Einschränkungen für beliebige Zwecke eingesetzt werden, solange es nicht verändert und unter gleichem Namen verbreitet wird.

Frog-Modul für Python 3: frog-2.2.3.zip