Turtle-Grafik mit Python 3.1 – Einführung - gems-hassee.degems-hassee.de/assets/TurtleGrafikPython.pdf · Turtle-Grafik mit Python 3.1 – Einführung Mit deinen Programmen kannst

Turtle-Grafik mit Python 3.1 – Einführung

Hardware und Software

Hardware:

Alle Computer bestehen aus folgenden Grundbausteinen:

Eingabegeräte (Tastatur, Maus, Scanner, Joystick, .....)Zentraleinheit ( Rechenwerk, Steuerwerk, Arbeitsspeicher, ...)Ausgabegeräte (Monitor, Drucker, Interface, ....)

Neben dem Hauptspeicher der Zentraleinheit (Arbeitsspeicher) benötigt man Speicher, mit de-ren Hilfe man Informationen (Daten) sichern kann:

USB-Stick mit USB-PortFestplatte mit FestplattenlaufwerkDiskette mit DiskettenlaufwerkCDs mit CD-ROM-Laufwerkund viele mehr

Man unterscheidet 2 Arten von Speichern:

Nur-Lese-Speicher : ROM (Read Only Memory)z. B. für das Steuerprogramm des Computers, CDs.Der Speicherinhalt lässt sich nicht verändern

Schreib-Lese-Speicher : RAM (Random Access Memory) Hauptspeicher, Disketten, USB-Stick, Festplatte.Daten können gelöscht und geändert werden.

Software:

Was bisher beschrieben wurde, sind die Geräte, die so genannte Hardware. Mit der Hardware eines Computers alleine kann man nichts anfangen. Damit ein Computer arbeiten kann, benö-tigt man Software. Software ist das Programm, die Arbeitsmethode. Anwenderprogramme (z. B. Textverarbeitungsprogramme) sind Programme, die der Benutzer für festgelegte Aufgaben benutzen kann (Schreiben, Zeichnen, Spiele, ...). Wenn du den Computer für eigene Aufgaben (Lernprogramme, Berechnungen, Spiele, ..) benutzen willst, brauchst du eine Programmier-sprache, die diese Aufgaben dem Computer verständlich macht. Computer verstehen nur diese eigens für sie geschaffenen Computersprachen.

Es gibt zahlreiche Programmiersprachen: Python, Delphi, Comal, Logo, BASIC, C, C++, Java, PHP und viele mehr.

In diesem Kurs benutzt du die Programmiersprache Python 3.1.

Du kannst dir Python 3.1 kostenlos im Internet herunterladen, um auch zu Hause weiter zu pro-grammieren:

http://www.python.org

Im Internet findest du auch zahlreiche Hilfen und Anleitungen.

Beim Programmieren erfährst du, dass der Computer ein „nimmermüdes Arbeitstier" ist und be-kommst eine Vorstellung, wie Computerprogramme entstehen.

Dierk Schröder, 19.01.2011 1


Mit deinen Programmen kannst du Bilder erstellen, Berechnungen durchführen, Texte bearbeiten lassen, Quizübungen durchführen, Spiele spielen u..v. m.Zeichnen mit Turtle-Grafik

Die „Turtle“ ist eine programmierbare „Schildkröte“, die auf dem Boden hin- und herlaufen kann und, falls der Zeichenstift abgesenkt ist, ihren zurückgelegten Weg aufzeichnet.

Starte Python, damit es losgehen kann.

IPI – Interaktiver Python Interpreter:

Du kannst sofort loslegen, wenn du in der Eingabezeile deine Befehle eingibst. Du gibst ein – Python gibt aus.

Damit du Turtle-Befehle benutzen kannst, musst du zuerst das Modul Turtle importieren.

>>> from turtle import * # es werden alle Turtle-Methoden geladen>>> mode("logo") # 0° -> Nord, 90° -> Ost, rechtsdrehend

Es passiert zunächst scheinbar nichts. Ab jetzt kannst du im interaktiven Modus (IPI) die ver-fügbaren Turtle-Befehle ausprobieren und sofort das Ergebnis des Befehls beobachten.

Alle was hinter # steht, ist ein Kommentar und wird vom Programm nicht beachtet.

>>> forward(200) # gehe 200 Pixel vor>>> right(90) # drehe dich um 90° nach rechts>>> forward(100) # gehe 100 Pixel vor>>> right(90) # drehe dich um 90° nach rechts>>> fd(200) # gehe 200 Pixel vor>>> rt(90) # drehe dich um 90° nach rechts>>> fd(100) # gehe 100 Pixel vor>>> rt(90) # drehe dich um 90° nach rechts>>> left(45) # drehe dich um 90° nach links>>> back(50) # gehe 50 Pixel zurück>>> pu() # hebe den Stift an>>> pd(-50,100) # gehe zum Punkt (-50,100)>>> down() # senke den Stift ab>>> forward(200) # gehe 200 Pixel vor>>> circle(50) # zeichne einen Kreis mt dem Radius 50 Pixel>>> pu() # hebe den Stift an>>> fd(50) # gehe 50 Pixel vor>>> down() # senke den Stift ab>>> circle(50,90) # zeichnet einen Bogen mit r=50 Pixel und Winkel=90°>>> lt(180) # drehe dich um 180° nach links>>> circle(50,90) # zeichnet einen Bogen mit r=50 Pixel und Winkel=90°>>> pd()>>> home() # die Turtle springt in die Bildmitte (0|0)>>> pd()>>> setheading(90) # die Turtle-Richtung wird auf 90° gesetzt.

IDLE – Befehle im Editor-Fenster eingeben:

Wähle File-New Window



Jetzt kannst du die Befehle in einzelne Zeilen schreiben. Du erhältst dann eine Pro-grammliste.Diese Liste kannst du beliebig verändern, und damit das Ausgbebild nach deinen Wünschen gestalten. Aber achte unbedingt auf die richtige Rechtschreibung (Syntax). Python verzeiht kei-ne Schreibfehler. Die Fehlermeldungen kommen erst, wenn du das Programm startest.

Beginne dein erstes Programm mit folgenden Zeilen:

from turtle import *

mode('logo') # Turtle zeigt bei 0° nach oben wie in Comalreset() # Turtle wird in den Anfangszustand versetztshape('turtle') # statt des Dreiecks wird eine Turtle angezeigtcolor('darkgreen') # die Zeichenfarbe wird auf dunkelgrün gesetztwidth(2) # die Linienbreite beträgt 2 Pixel…..…..…..

hier folgen jetzt die Befehle, die du schon oben ausprobiert hast. Du kannst die Befehlsliste be-liebig verlängern und verändern, bis du mit deinem Bild zufrieden bist.

Achtung! Dies muss die letzte Zeile deines Programms sein:

mainloop()Mit File-Save As kannst du dein Programm speichern.Wähle für die Dateinamen immer die Dateiendung .py!

Mit File-Open kannst du gespeicherte Programme öffnen und später weiter bearbeiten.

Es gibt noch Methoden, mit denen du den Grafik-Bildschirm beeinflussen kannst:

clear() # die Zeichnung der aktiven Turtle wird gelöschtreset() # die Turtle wird in den Anfangszustand versetztbye() # das Turtlefenster wird geschlossen

Mit den bisherigen Befehlen kannst du schon sehr schöne Bilder erzeugen. Es fehlt aber noch eine Methode, um Flächen auszufüllen:

color(red) # setzt Zeichenfarbe auf rotfillcolor('yellow') # setzt die Füllfarbe auf gelbbegin_fill # hier beginnt das auszufüllende Viereckfd(100)rt(90)fd(100)rt(90)fd(100)rt(90)fd(100)rt(90)end_fill # hier wird das geschlossene Viereck gefüllt

Wenn du dir die Zeichenschritte auf dem Grafikbildschirm in Ruhe ansehen willst, kannst du das Zeichnen verlangsamen.



speed(5) # 0:am Schnellsten, 10: schnell, 1: langsamdelay(5) # Verzögerung in Millisekunden (0: schnell)tracer(1) # schaltet Animation eintracer(0) # schaltet Animation aus

Relative Befehle:

Die Befehle

forward(x), backward(x), left(x), right(x), circle(r), circle(r,w)

bezeichnet man als relative Befehle, weil der Zeichenstift immer vom letzten Standort weiter zeichnet.

Absolute Befehle:

Die Befehle

setheading(w) und goto(x,y) bezeichnet man als absolute Befehle, weil der Zeichenstift unabhängig vom letzten Standort bewegt wird.

Bitte beachte: Dezimalbrüche (Kommazahlen) musst du immer mit Dezimalpunkt schreiben!Beispiel: nicht 4,7 sondern 4.7

Wiederholungen

Du hast oben ein Quadrat programmiert und festgestellt, dass du viermal die folgenden Befehle geschrieben hast:

fd(100)rt(90)

Das gleiche Ergebnis erhältst du mit einer Schleife (Wiederholung).

for i in range(4): # Beginn der Wiederholung. : nicht vergessen!fd(100) # wird viermal wiederholtrt(90) # wird viermal wiederholt

write('Die Wiederholung ist beendet')

Der Befehlsblock, der viermal wiederholt werden soll muss mit dem Tabulator gleichmäßig ein-gerückt werden.

range(4) ist eine Liste aus 4 Zahlen [0, 1, 2, 3]. Wenn die Liste durchlaufen wurde, ist die Wiederholung beendet und der nächste Befehl wird ausgeführt. i ist eine Variable, die den jeweiligen Listenwert von 0 bis 3 annimmt

for z in range(8): # Beginn der Wiederholung. : nicht vergessen!fd(100) # wird achtmal wiederholtrt(45) # wird achtmal wiederholtprint(z) # der Wert von z wird geschrieben

So geht’s auch:



a = 1 # die Variable a erhält den Wert 1while a<20: # wiederhole solange wie a kleiner als 20 ist

fd(a*5) # gehe 5*a Pixel vorwärtsrt(90)a = a+1 # a wird um 1 vergrößert

write('Die letzte Zahl war: '+str(a))

Der Benutzer kann auch selber bestimmen, wie oft wiederholt werden soll.

ecken=textinput('Vieleck','Wie viele Ecken?') # nur Ziffern eingebenlaenge=textinput('Eingabe','Seitenlänge?') # nur Ziffern eingebenanzahl=int(ecken) # Umwandlung Text in ganze Zahls=int(laenge) # Umwandlung Text in ganze Zahl (integer)begin_fill()for z in range(anzahl):

fd(s)rt(360/anzahl)write(z)

fillcolor('yellow')end_fill()name=textinput('Polygon','Wie heißt das Vieleck?')rt(90)pu()fd(s)write(name)home()pd()

Neue Befehle erfinden

Wenn du das Quadrat mit einem einzigen Befehl zeichnen möchtest kannst du die Methode selber definieren. Python lernt einen neuen Befehl quadrat(), den du wie alle anderen Py-thon-Befehle innerhalb des Programms benutzen kannst.Denke unbedingt an die (leere) Klammer und die Doppelpunkte, sonst funktioniert es nicht.

def quadrat():for i in range(4):

fd(100)rt(90)

Mit dem folgenden Befehl wird diese Methode ausgeführt:

quadrat()

Noch besser geht es so:

def quadrat(a):for i in range(4):

fd(a)rt(90)

Mit dem Befehl

quadrat(50)

wird ein Quadrat mit 50 Pixel Seitenlänge gezeichnet.



Hier siehst du, wie man den Befehl quadrat(s) einsetzen kann.

def muster():for i in range(1, 10):

quadrat(i*10)

range(1,10) erzeugt die Liste [1, 2, 3, …, 9] mit 9 Zahlen.Die Seitenlänge des Quadrats wird in jeder Runde verzehnfacht. (10, 20, 30, …;90)

Python kann auch würfeln

Wenn du Zufallszahlen erzeugen willst benötigst du die Befehlserweiterung random:

from random import * # es werden alle Zufalls-Methoden geladen

for i in range(20): x=randint(1,2) y=randint(3,4) print('x=',x,sep='',end=' ') print('y=',y,sep='')

Ein gut strukturiertes Programm besteht im Wesentlichen aus einzelnen Methodendefinitionen die bestimmte Teilaufgaben erledigen und überall im Programm zur Verfügung stehen. Der Aufruf einer neuen Methode def …(): muss unterhalb der Methodendefinition stehen.

Turtle-Befehle

Bewegung und Zeichnenforward(40), fd(40) die Turtle zeichnet 40 Pixel vorwärts back(30), bk(30) die Turtle bewegt sich rückwärts und zeichnet right(90), rt(90) dreht die Turtle um 90° weiter nach rechtsleft(60), lt(60) dreht die Turtle um 60° weiter nach linkscircle(30) zeichnet einen Kreisbogen links mit dem Radius 30 Pixel

circle(20,90) zeichnet einen Kreisbogen nach links mit einem Radius von 20 Pixel und einem Winkel von 90°

write('Hallo Welt', font=('Arial', 16))

Schreibt Hallo Welt in Schriftart Arial und Schriftgröße 16 an der aktuellen Position

dot(3,’red’) zeichnet einen Punkt mit dem Durchmesser 3 Pixel und der Far-be rot an der aktuellen Position

goto(100,200),setpos(100,200) setzt die Turtle auf den Punkt (100|200) und zeichnet

setheading(270),seth(270)

dreht die Turtle auf 270° (West), unabhängig von dem vorher eingestellten Winkel.

pu(), up() der Zeichenstift wird hochgenommen. (die Turtle bewegt sich danach ohne zu zeichnen)

pd(), down() der Zeichenstift wird heruntergesetzt. Die Turtle zeichnet wieder.



hideturtle(), ht() Turtle wird unsichtbarshowturtle(), st() Turtle wird sichtbar

s1=stamp() stempelt den Umriss der Turtle an der aktuellen Position. Stem-pelname ist s1

clearstamp(s1) löscht Stempel s1

clearstams(n)lösche alle, die ersten, die letzten von n Stempeln. Wenn die Klammer leer ist, werden alle gelöscht. Wenn n > 0 werden die ersten n Stempel, sonst die letzten n Stempel gelöscht

Position und Winkel bestimmenposition(), pos() gibt die (x|y)-Koordinaten der Turtle zurücktowards(x,y) gibt den Abstand bis zum Punkt (x|y) zurück xcor() gibt die x-Koordinate der Turtle zurück ycor() gibt die y-Koordinate der Turtle zurück heading() gibt den Winkel der Turtle zurück distance(x,y) gibt den Abstand der Turtle zum Punkt (x|y) zurück

Farben, Füllung, Aussehenwidth(3), pensize(3) setzt Linienbreite auf 3 Pixelcolor('red','yellow') die Zeichenfarbe ist rot, die Hintergrundfarbe ist gelbfillcolor('blue') die Hintergrundfarbe wird auf blau gesetzt.

begin_fill färbt folgende geschlossene Fläche mit aktueller Hintergrundfar-be aus.

end_fill färbt vorher geschlossene Fläche mit angegebener Farbe.bgcolor('pink') die Hintergrundfarbe wird auf pink gesetztbgpic('dateipfad') es wird ein Bild als Hintergrund geladen

shape('turtle') legt das Aussehen der Turtle fest ('arrow', 'turtle', 'circle', 'squa-re', 'triangle', 'classic').

Grafikbilschirm

setworldcoordinates(-10,-10,10,10)

legt das Koordinatensystem der Zeichenfläche auf die entspre-chenden Koordinaten fest. (Gibt u. a. Probleme mit circle(20,90))

title("Willkommen im Turtlezirkus!") Titelzeile im Grafikfenster

setup(width=200, height=200, startx=0, starty=0)

Das Grafikfenster wird auf die angegebenen Werte eingestellt.

bye() schließt das Grafikfensterclear() löscht die Zeichnung der Turtle z. B. paula.clear()clearscreen() löscht den Grafikbildschirm



Aktionen mit Maus und Tasten

listen() setzt den Focus auf das Fenster, um auf Maus und Tastatur zu reagieren.

onkey(funk,'T') funk wird ausgeführt wenn Taste 'T' gedrückt wirdonkeyrelease(funk,'T') funk wird ausgeführt wenn Taste 'T' losgelassen wirdonkeypress(funk,['T']) funk wird ausgeführt solange (irgendeine) Taste gedrückt wirdonscreenclick(funk) funk wird ausgeführt, wenn der Bildschirm angeklickt wird

onclick(test)beim Klicken auf die Turtle wird test(x|y) mit den Mauskoordina-ten (x|y) ausgeführt. Die aufgerufene Prozedur muss so aussehen def test(x,y):

onrelease(test2) test2(x|y) wird beim Loslassen mit den Mauskoordinaten (x|y) ausgeführt. def test2(x|y):

ondrag(test3)test3(x|y) wird beim Ziehen mit den Mauskoordinaten (x|y) aus-geführt. def test3(x|y):auch: ondrag(goto)

Variable und Co.a=2 weist der Variablen a den Wert 2 zu. fd(3*a) zeichnet eine Linie mit 6 Einheiten, wenn a gleich 2 ist

a+=3 oder a-=3 vergrößert (verkleinert) den Wert der Variablen a um 3.Wenn a gleich 2 ist, dann wird a=5 bzw. a=-1)

x=a**3 weist der Variablen x den Wert a³ zu. Wenn a=2 dann ist x=8

z=randint(1,6)vorher das Modul random importieren: from random import *z bekommt als Wert eine Zufallszahl zwischen 1 und 6 (würfeln)

y:=3x+2 es können beliebige Formeln als Zuweisung gewählt werdenzahl_str = textinput('Gib eine Zahl ein:')

Du kannst in einem Dialog einen beliebigen Text eingeben.

kommazahl = float(zahl_str)

Wenn der Text aus Ziffern besteht, wird der Text in eine Kom-mazahl (float) umgewandelt.

zahl = int(zahl_str) Wenn der Text aus Ziffern besteht, wird der Text in eine ganze Zahl (integer) umgewandelt.

Du benötigst schnell alle Informationen zu einem Befehl? Gib an der Eingabeauforderung help(Befehl) ein:

>>> from turtle import *>>> help(shape)>>> help(bgcolor)>>> help (mode)>>> help(bgpic)>>> help(Turtle)

Fehlerbehandlung



Trotz sorgfältiger Programmierung kann es zu so genannten Laufzeitfehlern kommen.Wenn vom Benutzer z. B. eine ganze Zahl eingegeben werden soll und eine Kommazahl (float) oder ein Text (string) eingegeben wird.

zahl = numinput('Eingabe','Gib eine ganze Zahl ein:',5,1,10)try: speed(zahl) # wenn hier abgebrochen wird …except: speed(5) # … geht's hier weiter

Lust auf ein Spiel?

Du kannst den Quelltext im Internet herunterladen:

http://igs-hassee.lernnetz.de/Silverstripe/Informatik (CatchMe.py)

# Catch me if you can! Paula fängt Horst, du fängst Paula.

from turtle import *from random import *mode('logo')

level = numinput("Fang' Paula!",'Wähle Level (1-10):',5,1,10)try: delay(10-int(level))except: delay(5)pu()goto(300,-250)rt(45)pd()begin_fill()fillcolor('pink')circle(400,360,4)end_fill()color('black','green')pu()goto(-50,300)pd()write('Catch me if you can! Paula fängt Horst, du fängst Paula')ht()pd()

def main(x,y): # x|y ist nötig, um Mauskoordinaten zu paula = Turtle() # übergeben paula.shape('turtle') paula.color('red','yellow') paula.pu() paula.goto(-250,290) paula.pd() horst = Turtle() horst.shape("turtle") horst.reset()



horst.pu() horst.goto(180,290) horst.pd() horst.color("black","darkgreen") paula.seth(towards(horst)) horst.seth(randint(180,270)) horst.stamp() paula.stamp() count = 1 geschafft=False def start(mx,my): # mx|my für Mauskoordinaten paula.clear() main(1,2) def gefangen(mx,my): if not geschafft: paula.write('Super, du hast Paula erwischt!') else: paula.write('Das zählt ja wohl nicht?!') onclick(start) # Mauskoordinaten werden paula.onclick(gefangen) # automatisch übergeben while paula.distance(horst) > 4: horst.fd(randint(3,7)) horst.lt(randint(-20,40)/10) paula.setheading(paula.towards(horst)) paula.fd(randint(1,10)) if count % 20 == 0: horst.stamp() paula.stamp() count += 1 if horst.ycor()<-260 or horst.xcor()>310: horst.write('Puh, geschafft!') paula.write('Mist, entwischt!') geschafft=True break if not geschafft: horst.write("Erwischt!",font=("Arial",14,"bold")") pu() goto(-200,-200) shape('circle') write(' Noch einmal? Hier klicken') pd() st()#****** end_main *********

main(1,2) # 1 und 2 sind "Dummyzahlen"

mainloop()

Dir fällt sicher noch eine Menge ein, um dieses Spiel zu erweitern.



Programmbeispiele I

Deine Bildschirmausgabe kann von den Beispielbildern abweichen, weil dort andere Koordina-ten eingestellt sind.

#Quadratmuster

from turtle import *mode('logo')

x=-150y=-150for i in range(5): pu() goto(x,y) pd() for i in range(4): fd(20) rt(90) x+=30 y+=30mainloop()

# Methodenfrom turtle import *from random import *mode('logo')

def schild(): fd(80) begin_fill rt(90) circle(20) lt(90) fillcolor('red') end_fill bk(80)

def schildmuehle(): n=randint(4,20) for i in range(n): schild rt(360/n)

schildmuehle()mainloop()



Programme mit Wiederholungen

Schreibe Programme, die folgende Bilder zeichnen:



Programmbeispiele II

Ändere die Befehlszeilen so um, dass die Prozeduren mit Python 3.1 funktionieren.

löschenx:=0y:=0seite:=2anzahl:=5

siedlunght

proc quadrat repeat(4) fd(Seite) rt(90) endendproc

proc dreieck repeat(3) fd(seite) rt(120) endendproc

proc baum pw(seite*10) pc(brown) fd(seite) pw(1) pc(green) lt(90) bogenr(seite/3,360) rt(90) pu fd(seite/3/2) fill(green) bk(seite/3/2) bk(seite) pd pc(darkblue)endproc

proc haus quadrat pu fd(seite) pd rt(30) dreieck lt(30) pu bk(seite) pdendproc

proc Straße repeat(Anzahl) mt(x,y) haus pu lt(90) fd(seite/4) rt(90) pd baum lt(90) pu bk(seite/4) rt(90) pd x:=x+seite+seite/1.5 y:=y+seite+seite/2 endendproc

proc Siedlung repeat(10) seite:=zufall(1,20)/10 anzahl:=1 straße endendproc



Schreibe Prozeduren für die folgenden Bilder:



Schreibe Programme für folgende Bilder:


Documents

Turtle-Grafik mit Python 3.1 – Einführung - gems-hassee.degems-hassee.de/assets/TurtleGrafikPython.pdf · Turtle-Grafik mit Python 3.1 – Einführung Mit deinen Programmen kannst