turtle — Turtle-Grafik

Quellcode: Lib/turtle.py

Stell dir eine Roboter-Turtle vor, die in der x-y-Ebene bei (0, 0) startet. Gib ihr nach einem import turtle den Befehl turtle.forward(15), und sie bewegt sich (auf dem Bildschirm!) 15 Pixel in die Richtung, in die sie schaut, und zeichnet dabei eine Linie. Gib ihr den Befehl turtle.right(25), und sie dreht sich auf der Stelle um 25 Grad im Uhrzeigersinn.

Turtle-Grafik ist eine Umsetzung der Zeichenwerkzeuge, die 1967 in Logo eingeführt wurden. Sie entstand als Lehrmittel, und ihre unmittelbare, sichtbare Rückmeldung macht sie zu einem wirksamen Mittel, damit Lernende mit Programmierkonzepten in Berührung kommen. Außerdem ist sie eine bequeme Möglichkeit, einfache grafische Ausgaben zu erzeugen, ohne externe Bibliotheken einzubinden.

Dieses Dokument umfasst vier Hauptabschnitte:

  • Tutorial vermittelt die Grundlagen des Zeichnens mit der Turtle.

  • Referenz beschreibt die Funktionen, Methoden und Klassen, die dieses Modul definiert.

  • How-to-Anleitungen beschreibt im Detail, wie bestimmte Aufgaben zu lösen sind.

  • Erklärung liefert Hintergrundinformationen zur objektorientierten Schnittstelle.

Bemerkung

Turtle-Grafik benötigt das optionale Modul tkinter. Die Installationsprogramme von python.org für Windows und macOS enthalten es, manche Linux-Distributionen und andere Plattformen packen es jedoch gesondert. Wenn import turtle mit einem Fehler scheitert, in dem _tkinter vorkommt, suche nach der Dokumentation deines Distributors (also dessen, der dir Python bereitgestellt hat). Prüfe das vorab, wenn du Turtle-Grafik mit Lernenden einsetzen willst.

Tutorial

Neue Benutzer sollten hier beginnen. In diesem Tutorial erkunden wir einige der Grundlagen des Turtle-Zeichnens.

Eine Turtle-Umgebung starten

Importiere in einer Python-Shell alle Objekte des Moduls turtle:

from turtle import *

Falls du auf einen Fehler Standard library module '_tkinter' was not found stößt, musst du das Tk-Interface-Paket auf deinem System installieren.

Noch erscheint nichts. Um das Turtle-Fenster zu öffnen, mache die Turtle sichtbar:

showturtle()

Ein neues Fenster öffnet sich, mit der Turtle in der Mitte, dargestellt als Pfeil, der nach Osten zeigt.

Einfaches Zeichnen

Schicke die Turtle 100 Schritte vorwärts:

forward(100)

Du solltest eine von der Turtle gezeichnete Linie sehen, die nach Osten zeigt. Ändere die Richtung der Turtle, sodass sie sich um 120 Grad nach links dreht (gegen den Uhrzeigersinn):

left(120)

Lass uns fortfahren, indem wir ein Dreieck zeichnen:

forward(100)
left(120)
forward(100)

Beachte, wie die Turtle, dargestellt durch einen Pfeil, in unterschiedliche Richtungen zeigt, während du sie steuerst.

Experimentiere mit diesen Befehlen und auch mit backward() und right(). Viele Befehle haben außerdem knappere Aliasnamen, etwa fd() für forward().

Stiftsteuerung

Versuche, die Farbe zu ändern – zum Beispiel color('blue') – sowie die Breite der Linie – zum Beispiel width(3) – und zeichne dann erneut.

Du kannst die Turtle auch bewegen, ohne zu zeichnen, indem du den Stift anhebst: up() vor dem Bewegen. Um wieder mit dem Zeichnen zu beginnen, verwende down().

Die Position der Turtle

Schicke deine Turtle zurück zu ihrem Startpunkt (nützlich, falls sie außerhalb des Bildschirms verschwunden ist):

home()

Die Home-Position befindet sich in der Mitte des Turtle-Bildschirms. Falls du sie jemals wissen musst, erhältst du die x-y-Koordinaten der Turtle mit:

pos()

Home liegt bei (0, 0).

Und nach einer Weile wird es wahrscheinlich helfen, das Fenster zu leeren, damit wir von vorne beginnen können:

clearscreen()

Algorithmische Muster erstellen

Mithilfe von Schleifen ist es möglich, geometrische Muster aufzubauen:

for steps in range(100):
    for c in ('blue', 'red', 'green'):
        color(c)
        forward(steps)
        right(30)

- die natürlich nur durch die Fantasie begrenzt werden!

Lass uns die Sternform am Anfang dieser Seite zeichnen. Wir wollen rote Linien, gefüllt mit Gelb:

color('red')
fillcolor('yellow')

Genau wie up() und down() bestimmen, ob Linien gezeichnet werden, kann das Füllen ein- und ausgeschaltet werden:

begin_fill()

Als Nächstes erstellen wir eine Schleife:

start = pos()

while True:
    forward(200)
    left(170)
    if distance(start) < 1:
        break

distance(start) < 1 ist eine gute Möglichkeit zu erkennen, wann die Turtle wieder an ihrer Startposition ist.

Schließlich vervollständige das Füllen:

end_fill()

(Beachte, dass das Füllen erst tatsächlich stattfindet, wenn du den Befehl end_fill() gibst.)

Referenz

Turtle-Methoden und -Funktionen

Turtle-Instanz namens turtle.

Bewegen und zeichnen

turtle.forward(distance)
turtle.fd(distance)
Parameter:

distance – eine Zahl

Bewege die Turtle um die angegebene distance vorwärts, in die Richtung, in die die Turtle blickt.

>>> turtle.position()
(0.00,0.00)
>>> turtle.forward(25)
>>> turtle.position()
(25.00,0.00)
>>> turtle.forward(-75)
>>> turtle.position()
(-50.00,0.00)
turtle.back(distance)
turtle.bk(distance)
turtle.backward(distance)
Parameter:

distance – eine Zahl

Bewege die Turtle um distance rückwärts, entgegen der Richtung, in die die Turtle blickt. Die Ausrichtung der Turtle wird dabei nicht verändert.

>>> turtle.position()
(0.00,0.00)
>>> turtle.backward(30)
>>> turtle.position()
(-30.00,0.00)
turtle.right(angle)
turtle.rt(angle)
Parameter:

angle – eine Zahl

Drehe die Turtle um den angegebenen angle nach rechts. Der Winkel wird standardmäßig in Grad gemessen, die Einheit lässt sich mit degrees() oder radians() ändern. Wie die Ausrichtung gemessen wird, hängt vom Turtle-Modus ab, siehe mode().

>>> turtle.heading()
22.0
>>> turtle.right(45)
>>> turtle.heading()
337.0
turtle.left(angle)
turtle.lt(angle)
Parameter:

angle – eine Zahl

Drehe die Turtle um den angegebenen angle nach links. Der Winkel wird standardmäßig in Grad gemessen, die Einheit lässt sich mit degrees() oder radians() ändern. Wie die Ausrichtung gemessen wird, hängt vom Turtle-Modus ab, siehe mode().

>>> turtle.heading()
22.0
>>> turtle.left(45)
>>> turtle.heading()
67.0
turtle.goto(x, y=None)
turtle.setpos(x, y=None)
turtle.setposition(x, y=None)
Parameter:

  • x – eine Zahl oder ein Paar/Vektor von Zahlen

  • y – eine Zahl oder None

Bewege die Turtle an eine absolute Position. Ist y None, muss x ein Koordinatenpaar oder ein Vec2D sein, zum Beispiel wie von pos() zurückgegeben. Ist der Stift unten, wird eine Linie gezeichnet. Die Ausrichtung der Turtle ändert sich nicht.

>>> tp = turtle.pos()
>>> tp
(0.00,0.00)
>>> turtle.goto(60,30)
>>> turtle.pos()
(60.00,30.00)
>>> turtle.goto((20,80))
>>> turtle.pos()
(20.00,80.00)
>>> turtle.goto(tp)
>>> turtle.pos()
(0.00,0.00)
turtle.teleport(x=None, y=None, *, fill_gap=False)
Parameter:

  • x – eine Zahl oder None

  • y – eine Zahl oder None

  • fill_gap – Ein Boolean

Versetze die Turtle unmittelbar an eine absolute Position. Anders als bei goto() wird keine Linie gezeichnet. Wird x oder y nicht angegeben, bleibt diese Koordinate unverändert. Die Ausrichtung der Turtle ändert sich nicht.

Füllt die Turtle gerade eine Form, wird die bisher gezeichnete Form vor dem Versetzen abgeschlossen und gefüllt, und das Füllen beginnt an der neuen Position erneut. Übergib fill_gap=True, um stattdessen eine einzige Form weiterzufüllen. Das Versetzen zählt dann als Kante der Form, so wie es bei goto() wäre.

>>> tp = turtle.pos()
>>> tp
(0.00,0.00)
>>> turtle.teleport(60)
>>> turtle.pos()
(60.00,0.00)
>>> turtle.teleport(y=10)
>>> turtle.pos()
(60.00,10.00)
>>> turtle.teleport(20, 30)
>>> turtle.pos()
(20.00,30.00)

Added in version 3.12.

turtle.setx(x)
Parameter:

x – eine Zahl

Setze die x-Koordinate der Turtle auf x. Die y-Koordinate bleibt unverändert.

>>> turtle.position()
(0.00,240.00)
>>> turtle.setx(10)
>>> turtle.position()
(10.00,240.00)
turtle.sety(y)
Parameter:

y – eine Zahl

Setze die y-Koordinate der Turtle auf y. Die x-Koordinate bleibt unverändert.

>>> turtle.position()
(0.00,40.00)
>>> turtle.sety(-10)
>>> turtle.position()
(0.00,-10.00)
turtle.setheading(to_angle)
turtle.seth(to_angle)
Parameter:

to_angle – eine Zahl

Setze die Ausrichtung der Turtle auf to_angle. Hier sind einige gängige Richtungen in Grad:

Standardmodus

Logo-Modus

0 - Ost

0 - Nord

90 - Nord

90 - Ost

180 - West

180 - Süd

270 - Süd

270 - West

 
>>> turtle.setheading(90)
>>> turtle.heading()
90.0
turtle.home()

Bewege die Turtle zum Ursprung, Koordinaten (0,0). Die Ausrichtung der Turtle wird auf ihre Startausrichtung gesetzt, die vom Turtle-Modus abhängt, siehe mode().

>>> turtle.heading()
90.0
>>> turtle.position()
(0.00,-10.00)
>>> turtle.home()
>>> turtle.position()
(0.00,0.00)
>>> turtle.heading()
0.0
turtle.circle(radius, extent=None, steps=None)
Parameter:

  • radius – eine Zahl

  • extent – eine Zahl oder None

  • steps – eine Ganzzahl oder None

Zeichne einen Kreis mit dem angegebenen radius. Der Mittelpunkt liegt radius Einheiten links von der Turtle, extent – ein Winkel – bestimmt, welcher Teil des Kreises gezeichnet wird. Wird extent nicht angegeben, wird der gesamte Kreis gezeichnet. Ist extent kein voller Kreis, ist ein Endpunkt des Bogens die aktuelle Stiftposition. Zeichne den Bogen gegen den Uhrzeigersinn, wenn radius positiv ist, andernfalls im Uhrzeigersinn. Abschließend wird die Richtung der Turtle um den Betrag von extent geändert.

Da der Kreis durch ein einbeschriebenes regelmäßiges Vieleck angenähert wird, bestimmt steps die Anzahl der zu verwendenden Schritte. Wird es nicht angegeben, wird es automatisch berechnet. Kann verwendet werden, um regelmäßige Vielecke zu zeichnen.

>>> turtle.home()
>>> turtle.position()
(0.00,0.00)
>>> turtle.heading()
0.0
>>> turtle.circle(50)
>>> turtle.position()
(-0.00,0.00)
>>> turtle.heading()
0.0
>>> turtle.circle(120, 180)  # draw a semicircle
>>> turtle.position()
(0.00,240.00)
>>> turtle.heading()
180.0
turtle.dot()
turtle.dot(size)
turtle.dot(color, /)
turtle.dot(size, color, /)
turtle.dot(size, r, g, b, /)
Parameter:

  • size – eine positive Ganzzahl oder None

  • color – ein Farbstring oder ein numerisches Farb-Tupel

Zeichne einen kreisförmigen Punkt mit dem Durchmesser size in der Farbe color. Wird size nicht angegeben, wird das Maximum aus pensize + 4 und 2 * pensize verwendet. Wird color nicht angegeben, wird die aktuelle Stiftfarbe verwendet.

>>> turtle.home()
>>> turtle.dot()
>>> turtle.fd(50); turtle.dot(20, "blue"); turtle.fd(50)
>>> turtle.position()
(100.00,-0.00)
>>> turtle.heading()
0.0
turtle.stamp()

Stamp a copy of the turtle shape onto the canvas and return its id. The stamp is placed at the current turtle position. The returned id can be used to delete the stamp with clearstamp().

>>> turtle.color("blue")
>>> stamp_id = turtle.stamp()
>>> turtle.fd(50)
turtle.clearstamp(stampid)
Parameter:

stampid – eine Ganzzahl

Delete the stamp with the given stampid. stampid must be the return value of a previous stamp() call.

>>> turtle.position()
(150.00,-0.00)
>>> turtle.color("blue")
>>> astamp = turtle.stamp()
>>> turtle.fd(50)
>>> turtle.position()
(200.00,-0.00)
>>> turtle.clearstamp(astamp)
>>> turtle.position()
(200.00,-0.00)
turtle.clearstamps(n=None)
Parameter:

n – eine Ganzzahl oder None

Delete all or the first or last n of the turtle’s stamps. If n is not given, delete all stamps. If n is positive, delete the first n stamps. If n is negative, delete the last n stamps, so -2 deletes the last two.

>>> for i in range(8):
...     unused_stamp_id = turtle.stamp()
...     turtle.fd(30)
>>> turtle.clearstamps(2)
>>> turtle.clearstamps(-2)
>>> turtle.clearstamps()
turtle.undo()

Mache die letzte(n) Turtle-Aktion(en) (wiederholt) rückgängig. Die Anzahl der verfügbaren Rückgängig-Aktionen wird durch die Größe des Undo-Puffers bestimmt.

>>> for i in range(4):
...     turtle.fd(50); turtle.lt(80)
...
>>> for i in range(8):
...     turtle.undo()
turtle.speed(speed=None)
Parameter:

speed – eine Ganzzahl, eine Zeichenkette oder None

Gib die Geschwindigkeit der Turtle zurück oder setze sie. Wird speed nicht angegeben, wird die aktuelle Geschwindigkeit zurückgegeben. Andernfalls wird die Geschwindigkeit der Turtle auf eine Ganzzahl von 0 bis 10 gesetzt. Ist speed eine Zahl größer als 10 oder kleiner als 0,5, wird die Geschwindigkeit auf 0 gesetzt. Du kannst auch diese Namen anstelle von Zahlen verwenden:

  • „fastest“: 0

  • „fast“: 10

  • „normal“: 6

  • „slow“: 3

  • „slowest“: 1

Geschwindigkeiten von 1 bis 10 ergeben eine zunehmend schnellere Animation beim Zeichnen von Linien und beim Drehen der Turtle. Eine Geschwindigkeit von 0 bedeutet, dass keine Animation stattfindet: forward() und back() lassen die Turtle springen, und ebenso lassen left() und right() die Turtle sofort drehen.

>>> turtle.speed()
3
>>> turtle.speed('normal')
>>> turtle.speed()
6
>>> turtle.speed(9)
>>> turtle.speed()
9

Zustand der Turtle abfragen

turtle.position()
turtle.pos()

Gib die aktuelle Position der Turtle (x,y) als Vec2D-Vektor zurück.

>>> turtle.pos()
(440.00,-0.00)
turtle.towards(x, y=None)
Parameter:

  • x – eine Zahl oder ein Paar/Vektor von Zahlen oder eine Turtle-Instanz

  • y – eine Zahl, falls x eine Zahl ist, andernfalls None

Gib den Winkel der Linie von der Position der Turtle zu (x,y) zurück. Ist y None, muss x ein Koordinatenpaar sein, ein Vec2D – zum Beispiel wie von pos() zurückgegeben – oder eine andere Turtle. Der Winkel wird von der Startausrichtung der Turtle aus gemessen, die vom Turtle-Modus abhängt, siehe mode().

>>> turtle.goto(10, 10)
>>> turtle.towards(0,0)
225.0
turtle.xcor()

Gib die x-Koordinate der Turtle zurück.

>>> turtle.home()
>>> turtle.left(50)
>>> turtle.forward(100)
>>> turtle.pos()
(64.28,76.60)
>>> print(round(turtle.xcor(), 5))
64.27876
turtle.ycor()

Gib die y-Koordinate der Turtle zurück.

>>> turtle.home()
>>> turtle.left(60)
>>> turtle.forward(100)
>>> print(turtle.pos())
(50.00,86.60)
>>> print(round(turtle.ycor(), 5))
86.60254
turtle.heading()

Gib die aktuelle Ausrichtung der Turtle zurück. Der Wert hängt vom Turtle-Modus ab, siehe mode().

>>> turtle.home()
>>> turtle.left(67)
>>> turtle.heading()
67.0
turtle.distance(x, y=None)
Parameter:

  • x – eine Zahl oder ein Paar/Vektor von Zahlen oder eine Turtle-Instanz

  • y – eine Zahl, falls x eine Zahl ist, andernfalls None

Gib den Abstand von der Turtle zu (x,y) in Turtle-Schritteinheiten zurück. Ist y None, muss x ein Koordinatenpaar sein, ein Vec2D – zum Beispiel wie von pos() zurückgegeben – oder eine andere Turtle.

>>> turtle.home()
>>> turtle.distance(30,40)
50.0
>>> turtle.distance((30,40))
50.0
>>> joe = Turtle()
>>> joe.forward(77)
>>> turtle.distance(joe)
77.0

Einstellungen für Messungen

turtle.degrees(fullcircle=360.0)
Parameter:

fullcircle – eine Zahl

Setze die Winkelmesseinheiten auf Grad. Die Anzahl der Grad für einen vollen Kreis wird auf fullcircle gesetzt, standardmäßig 360.

>>> turtle.home()
>>> turtle.left(90)
>>> turtle.heading()
90.0

>>> # Change angle measurement unit to grad (also known as gon,
>>> # grade, or gradian and equals 1/100-th of the right angle.)
>>> turtle.degrees(400.0)
>>> turtle.heading()
100.0
>>> turtle.degrees(360)
>>> turtle.heading()
90.0
turtle.radians()

Setze die Winkelmesseinheiten auf Radiant. Entspricht degrees(2 * math.pi).

>>> turtle.home()
>>> turtle.left(90)
>>> turtle.heading()
90.0
>>> turtle.radians()
>>> turtle.heading()
1.5707963267948966

Stiftsteuerung

Zeichenzustand
turtle.pendown()
turtle.pd()
turtle.down()

Senke den Stift. Die Turtle zeichnet eine Linie, wenn sie sich bewegt.

turtle.penup()
turtle.pu()
turtle.up()

Hebe den Stift. Die Turtle zeichnet nicht, wenn sie sich bewegt.

turtle.pensize(width=None)
turtle.width(width=None)
Parameter:

width – eine positive Zahl oder None

Gib die Liniendicke zurück oder setze sie. Wird width nicht angegeben, wird die aktuelle Stiftgröße zurückgegeben. Ist resizemode auf „auto“ gesetzt und die Form der Turtle ein Polygon, wird dieses Polygon mit derselben Liniendicke gezeichnet.

>>> turtle.pensize()
1
>>> turtle.pensize(10)   # from here on lines of width 10 are drawn
turtle.pen(pen=None, **pendict)
Parameter:

  • pen – a dictionary or None

  • pendict – keyword arguments with the keys below

Return or set the pen’s attributes. The attributes are returned as a dictionary with the following keys and values:

  • „shown“: True or False

  • „pendown“: True or False

  • „pencolor“: a color string or a color tuple

  • „fillcolor“: a color string or a color tuple

  • „pensize“: a positive number

  • „speed“: a number from 0 to 10

  • „resizemode“: „auto“, „user“ or „noresize“

  • „stretchfactor“: a pair of positive numbers

  • „shearfactor“: a number

  • „outline“: a positive number

  • „tilt“: a number

Such a dictionary can be passed as pen to restore a former pen state. The attributes can also be given as keyword arguments, which can be used to set several of them in one statement.

>>> turtle.pen(fillcolor="black", pencolor="red", pensize=10)
>>> turtle.pen()
{'shown': True, 'pendown': True, 'pencolor': 'red', 'fillcolor': 'black',
 'pensize': 10, 'speed': 9, 'resizemode': 'noresize',
 'stretchfactor': (1.0, 1.0), 'shearfactor': 0.0, 'outline': 1,
 'tilt': 0.0}
>>> penstate = turtle.pen()
>>> turtle.color("yellow", "")
>>> turtle.penup()
>>> turtle.pen()["pencolor"]
'yellow'
>>> # restore the saved pen state, but with a green fill
>>> turtle.pen(penstate, fillcolor="green")
>>> turtle.pen()["pencolor"]
'red'
>>> turtle.pen()["fillcolor"]
'green'
turtle.isdown()

Gib True zurück, wenn der Stift unten ist, False, wenn er oben ist.

>>> turtle.penup()
>>> turtle.isdown()
False
>>> turtle.pendown()
>>> turtle.isdown()
True
Farbkontrolle
turtle.pencolor()
turtle.pencolor(color, /)
turtle.pencolor(r, g, b, /)

Gib die Stiftfarbe zurück oder setze sie.

Vier Eingabeformate sind erlaubt:

pencolor()

Gib die aktuelle Stiftfarbe als Farbangabe-Zeichenkette oder als Tupel zurück (siehe Beispiel). Kann als Eingabe für einen weiteren Aufruf von color(), pencolor(), fillcolor() oder bgcolor() verwendet werden.

pencolor(colorstring)

Setze die Stiftfarbe auf colorstring, was ein Tk-Farbangabe-String ist, wie zum Beispiel "red", "yellow" oder "#33cc8c".

pencolor((r, g, b))

Setze die Stiftfarbe auf die durch das Tupel aus r, g und b dargestellte RGB-Farbe. Jeder der Werte r, g und b muss im Bereich 0..colormode liegen, wobei colormode entweder 1.0 oder 255 ist (siehe colormode()).

pencolor(r, g, b)

Setze die Stiftfarbe auf die durch r, g und b dargestellte RGB-Farbe. Jeder der Werte r, g und b muss im Bereich 0..colormode liegen.

Ist die Form der Turtle ein Polygon, wird der Umriss dieses Polygons mit der neu gesetzten Stiftfarbe gezeichnet.

>>> colormode()
1.0
>>> turtle.pencolor()
'red'
>>> turtle.pencolor("brown")
>>> turtle.pencolor()
'brown'
>>> tup = (0.2, 0.8, 0.55)
>>> turtle.pencolor(tup)
>>> turtle.pencolor()
(0.2, 0.8, 0.5490196078431373)
>>> colormode(255)
>>> turtle.pencolor()
(51.0, 204.0, 140.0)
>>> turtle.pencolor('#32c18f')
>>> turtle.pencolor()
(50.0, 193.0, 143.0)
turtle.fillcolor()
turtle.fillcolor(color, /)
turtle.fillcolor(r, g, b, /)

Gib die Füllfarbe zurück oder setze sie.

Vier Eingabeformate sind erlaubt:

fillcolor()

Gib die aktuelle Füllfarbe als Farbangabe-Zeichenkette zurück, möglicherweise im Tupel-Format (siehe Beispiel). Kann als Eingabe für einen weiteren Aufruf von color(), pencolor(), fillcolor() oder bgcolor() verwendet werden.

fillcolor(colorstring)

Setze die Füllfarbe auf colorstring, was ein Tk-Farbangabe-String ist, wie zum Beispiel "red", "yellow" oder "#33cc8c".

fillcolor((r, g, b))

Setze die Füllfarbe auf die durch das Tupel aus r, g und b dargestellte RGB-Farbe. Jeder der Werte r, g und b muss im Bereich 0..colormode liegen, wobei colormode entweder 1.0 oder 255 ist (siehe colormode()).

fillcolor(r, g, b)

Setze die Füllfarbe auf die durch r, g und b dargestellte RGB-Farbe. Jeder der Werte r, g und b muss im Bereich 0..colormode liegen.

Ist die Form der Turtle ein Polygon, wird das Innere dieses Polygons mit der neu gesetzten Füllfarbe gezeichnet.

>>> turtle.fillcolor("violet")
>>> turtle.fillcolor()
'violet'
>>> turtle.pencolor()
(50.0, 193.0, 143.0)
>>> turtle.fillcolor((50, 193, 143))  # Integers, not floats
>>> turtle.fillcolor()
(50.0, 193.0, 143.0)
>>> turtle.fillcolor('#ffffff')
>>> turtle.fillcolor()
(255.0, 255.0, 255.0)
turtle.color()
turtle.color(color, /)
turtle.color(r, g, b, /)
turtle.color(pencolor, fillcolor, /)

Gib die Stiftfarbe und die Füllfarbe zurück oder setze sie.

Mehrere Eingabeformate sind erlaubt. Sie verwenden dabei 0 bis 3 Argumente wie folgt:

color()

Gib die aktuelle Stiftfarbe und die aktuelle Füllfarbe als Paar von Farbangabe-Strings oder Tupeln zurück, wie sie von pencolor() und fillcolor() zurückgegeben werden.

color(colorstring), color((r,g,b)), color(r,g,b)

Eingaben wie bei pencolor(), setzt sowohl fillcolor als auch pencolor auf den angegebenen Wert.

color(colorstring1, colorstring2), color((r1,g1,b1), (r2,g2,b2))

Entspricht pencolor(colorstring1) und fillcolor(colorstring2) und analog, wenn das andere Eingabeformat verwendet wird.

Ist die Form der Turtle ein Polygon, werden Umriss und Inneres dieses Polygons mit den neu gesetzten Farben gezeichnet.

>>> turtle.color("red", "green")
>>> turtle.color()
('red', 'green')
>>> color("#285078", "#a0c8f0")
>>> color()
((40.0, 80.0, 120.0), (160.0, 200.0, 240.0))

Siehe auch: Screen-Methode colormode().

Füllen
turtle.filling()

Gib True zurück, wenn die Turtle gerade füllt, andernfalls False.

>>> turtle.begin_fill()
>>> if turtle.filling():
...    turtle.pensize(5)
... else:
...    turtle.pensize(3)
turtle.fill()

Fill the shape drawn in the with block.

>>> turtle.color("black", "red")
>>> with turtle.fill():
...     turtle.circle(80)

fill() is a context manager, so using it is the same as calling begin_fill() before the block and end_fill() after it:

>>> turtle.color("black", "red")
>>> turtle.begin_fill()
>>> turtle.circle(80)
>>> turtle.end_fill()

Added in version 3.14.

turtle.begin_fill()

Call just before drawing a shape to be filled. The shape is filled by the next call to end_fill().

turtle.end_fill()

Fülle die Form, die seit dem letzten Aufruf von begin_fill() gezeichnet wurde.

If the shape crosses itself or several shapes overlap, whether the overlapping parts are filled depends on the operating system, the type of overlap and how many there are. For example, the turtle star above may be either all yellow or have some white regions.

>>> turtle.color("black", "red")
>>> turtle.begin_fill()
>>> turtle.circle(80)
>>> turtle.end_fill()
Mehr Zeichenkontrolle
turtle.reset()

Lösche die Zeichnungen der Turtle und zentriere die Turtle neu. Die Einstellungen der Turtle werden auf ihre Standardwerte zurückgesetzt.

>>> turtle.goto(0,-22)
>>> turtle.left(100)
>>> turtle.position()
(0.00,-22.00)
>>> turtle.heading()
100.0
>>> turtle.reset()
>>> turtle.position()
(0.00,0.00)
>>> turtle.heading()
0.0
turtle.clear()

Lösche die Zeichnungen der Turtle vom Bildschirm. Zustand und Position der Turtle sowie die Zeichnungen anderer Turtles bleiben davon unberührt.

turtle.write(arg, move=False, align='left', font=('Arial', 8, 'normal'))
Parameter:

  • arg – an object

  • move – Ein Boolean

  • align – eine Zeichenkette

  • font – a tuple of a string, an integer and a string

Write text at the current turtle position. The text is the string representation of arg. align is one of the strings „left“, „center“ or „right“ and says how the text is placed relative to the turtle position. font is a triple of font name, font size and font type. If move is True, the pen is moved to the bottom-right corner of the text.

>>> turtle.write("Home = ", True, align="center")
>>> turtle.write((0,0), True)

Turtle-Status

Sichtbarkeit
turtle.hideturtle()
turtle.ht()

Mache die Turtle unsichtbar. Ist der Stift unten, zeichnet eine Bewegung weiterhin.

turtle.showturtle()
turtle.st()

Mache die Turtle sichtbar.

turtle.isvisible()

Gib True zurück, wenn die Turtle sichtbar ist, False, wenn sie versteckt ist.

>>> turtle.hideturtle()
>>> turtle.isvisible()
False
>>> turtle.showturtle()
>>> turtle.isvisible()
True
Erscheinungsbild
turtle.shape(name=None)
Parameter:

name – eine Zeichenkette oder None

Setze die Form der Turtle auf die Form mit dem angegebenen Namen. Wird name nicht angegeben, wird der Name der aktuellen Form zurückgegeben. Die Form muss im Formen-Dictionary des TurtleScreen vorhanden sein. Anfangs gibt es die folgenden Formen: „arrow“, „turtle“, „circle“, „square“, „triangle“ und „classic“. Um Formen hinzuzufügen, siehe die Screen-Methode register_shape().

>>> turtle.shape()
'classic'
>>> turtle.shape("turtle")
>>> turtle.shape()
'turtle'
turtle.resizemode(rmode=None)
Parameter:

rmode – eine Zeichenkette oder None

Setze resizemode auf „auto“, „user“ oder „noresize“. Wird rmode nicht angegeben, wird der aktuelle resizemode zurückgegeben. Die verschiedenen resizemodes haben folgende Auswirkungen:

  • „auto“: Die Größe der Turtle richtet sich nach dem Wert von pensize().

  • „user“: Die Größe der Turtle richtet sich nach den Streckfaktoren und der Umrissbreite, die shapesize() setzt.

  • „noresize“: Die Größe der Turtle wird nicht verändert.

resizemode("user") wird von shapesize() aufgerufen, wenn es mit Argumenten verwendet wird.

>>> turtle.resizemode()
'noresize'
>>> turtle.resizemode("auto")
>>> turtle.resizemode()
'auto'
turtle.shapesize(stretch_wid=None, stretch_len=None, outline=None)
turtle.turtlesize(stretch_wid=None, stretch_len=None, outline=None)
Parameter:

  • stretch_wid – eine positive Zahl oder None

  • stretch_len – eine positive Zahl oder None

  • outline – eine positive Zahl oder None

Gib die Streckfaktoren und die Umrissbreite der Turtle zurück oder setze sie. Werden keine Argumente angegeben, werden die aktuellen Werte zurückgegeben. Andernfalls wird resizemode auf „user“ gesetzt, sodass die Turtle entsprechend ihren Streckfaktoren gestreckt dargestellt wird:

  • stretch_wid: der Streckfaktor senkrecht zur Ausrichtung der Turtle

  • stretch_len: der Streckfaktor in Richtung der Ausrichtung der Turtle

  • outline: die Breite des Umrisses der Form

shapesize(2, 1) macht die Turtle zum Beispiel doppelt so breit, ohne ihre Länge zu ändern. Wird nur stretch_wid angegeben, wird stretch_len auf denselben Wert gesetzt.

>>> turtle.shapesize()
(1.0, 1.0, 1)
>>> turtle.resizemode("user")
>>> turtle.shapesize(5, 5, 12)
>>> turtle.shapesize()
(5, 5, 12)
>>> turtle.shapesize(outline=8)
>>> turtle.shapesize()
(5, 5, 8)
turtle.shearfactor(shear=None)
Parameter:

shear – eine Zahl oder None

Return or set the current shear factor. Shearing slants the turtle shape, like the slant of italic letters. The shear factor says how much it is slanted: 0 is not slanted at all, and the larger the number, the stronger the slant. Negative numbers slant the other way. If shear is not given, return the current shear factor. Otherwise slant the turtle shape accordingly and set resizemode to „user“. The turtle’s heading does not change. Precisely, the shear factor is the tangent of the shear angle.

>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.shearfactor(0.5)
>>> turtle.shearfactor()
0.5
turtle.tilt(angle)
Parameter:

angle – eine Zahl

Turn the turtle shape by angle from its current tilt angle. The turtle’s heading does not change, so the turtle keeps moving in the same direction. See tiltangle().

>>> turtle.reset()
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(30)
>>> turtle.fd(50)
>>> turtle.tilt(30)
>>> turtle.fd(50)
turtle.tiltangle(angle=None)
Parameter:

angle – eine Zahl oder None

Return or set the current tilt angle. The tilt angle is the angle between the direction the turtle shape points in and the direction the turtle moves in. Normally the shape points in the direction of movement, so the tilt angle is 0. If angle is given, turn the turtle shape to that tilt angle, no matter what it was before, and set resizemode to „user“. The turtle’s heading does not change. If angle is not given, return the current tilt angle.

>>> turtle.reset()
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(45)
>>> turtle.tiltangle()
45.0
turtle.shapetransform(t11=None, t12=None, t21=None, t22=None)
Parameter:

  • t11 – eine Zahl oder None

  • t12 – eine Zahl oder None

  • t21 – eine Zahl oder None

  • t22 – eine Zahl oder None

Return or set the transformation matrix of the turtle shape. The matrix combines the stretch factors, the shear factor and the tilt angle of the turtle shape into four numbers: t11 and t12 form its first row, t21 and t22 its second. If none of them are given, return the current matrix as a tuple of four numbers. Otherwise set the given elements and update the stretch factors, shear factor and tilt angle accordingly. t11 * t22 - t12 * t21 must not be zero, otherwise an error is raised.

>>> turtle = Turtle()
>>> turtle.shape("square")
>>> turtle.shapesize(4,2)
>>> turtle.shearfactor(-0.5)
>>> turtle.shapetransform()
(4.0, -1.0, -0.0, 2.0)
turtle.get_shapepoly()

Return the points that form the outline of the current turtle shape as a tuple of (x, y) coordinate pairs. These points can be used to define a new shape or parts of a compound shape

>>> turtle.shape("square")
>>> turtle.shapetransform(4, -1, 0, 2)
>>> turtle.get_shapepoly()
((50, -20), (30, 20), (-50, 20), (-30, -20))

Ereignisse verwenden

turtle.onclick(fun, btn=1, add=None)
Parameter:

  • fun – eine Funktion mit zwei Argumenten oder None

  • btn – eine Ganzzahl

  • add – ein Wahrheitswert oder None

Binde fun an Mausklick-Ereignisse auf dieser Turtle. fun wird mit den Koordinaten des angeklickten Punktes auf der Leinwand aufgerufen. Ist fun None, werden bestehende Bindungen entfernt. btn ist die Nummer der Maustaste und ist standardmäßig 1, die linke Maustaste. Ist add True, wird eine neue Bindung hinzugefügt, andernfalls ersetzt sie eine frühere Bindung. Beispiel für die anonyme Turtle, also der prozedurale Weg:

>>> def turn(x, y):
...     left(180)
...
>>> onclick(turn)  # Now clicking into the turtle will turn it.
>>> onclick(None)  # event-binding will be removed
turtle.onrelease(fun, btn=1, add=None)
Parameter:

  • fun – eine Funktion mit zwei Argumenten, die mit den Koordinaten des angeklickten Punkts auf der Zeichenfläche aufgerufen wird

  • btn – Nummer der Maustaste, standardmäßig 1 (linke Maustaste)

  • add – True oder False – ist es True, wird eine neue Bindung hinzugefügt, andernfalls ersetzt sie eine vorherige Bindung

Binde fun an Loslassen-der-Maustaste-Ereignisse dieser Turtle. Ist fun None, werden bestehende Bindungen entfernt.

>>> class MyTurtle(Turtle):
...     def glow(self,x,y):
...         self.fillcolor("red")
...     def unglow(self,x,y):
...         self.fillcolor("")
...
>>> turtle = MyTurtle()
>>> turtle.onclick(turtle.glow)     # clicking on turtle turns fillcolor red,
>>> turtle.onrelease(turtle.unglow) # releasing turns it to transparent.
turtle.ondrag(fun, btn=1, add=None)
Parameter:

  • fun – eine Funktion mit zwei Argumenten, die mit den Koordinaten des angeklickten Punkts auf der Zeichenfläche aufgerufen wird

  • btn – Nummer der Maustaste, standardmäßig 1 (linke Maustaste)

  • add – True oder False – ist es True, wird eine neue Bindung hinzugefügt, andernfalls ersetzt sie eine vorherige Bindung

Binde fun an Mausbewegungs-Ereignisse dieser Turtle. Ist fun None, werden bestehende Bindungen entfernt.

Anmerkung: Jeder Abfolge von Mausbewegungs-Ereignissen auf einer Turtle geht ein Mausklick-Ereignis auf dieser Turtle voraus.

>>> turtle.ondrag(turtle.goto)

Anschließend bewegt das Klicken und Ziehen der Turtle diese über den Bildschirm und erzeugt dabei Handzeichnungen (wenn der Stift unten ist).

Spezielle Turtle-Methoden

turtle.poly()

Record the vertices of a polygon drawn in the with block. The first and last vertices will be connected.

>>> with turtle.poly():
...     turtle.forward(100)
...     turtle.right(60)
...     turtle.forward(100)

poly() is a context manager, so using it is the same as calling begin_poly() before the block and end_poly() after it:

>>> turtle.begin_poly()
>>> turtle.forward(100)
>>> turtle.right(60)
>>> turtle.forward(100)
>>> turtle.end_poly()

Added in version 3.14.

turtle.begin_poly()

Beginne mit dem Aufzeichnen der Eckpunkte eines Polygons. Die aktuelle Position der Turtle ist der erste Eckpunkt des Polygons.

turtle.end_poly()

Beende das Aufzeichnen der Eckpunkte eines Polygons. Die aktuelle Position der Turtle ist der letzte Eckpunkt des Polygons. Dieser wird mit dem ersten Eckpunkt verbunden.

turtle.get_poly()

Gib das zuletzt aufgezeichnete Polygon zurück.

>>> turtle.home()
>>> turtle.begin_poly()
>>> turtle.fd(100)
>>> turtle.left(20)
>>> turtle.fd(30)
>>> turtle.left(60)
>>> turtle.fd(50)
>>> turtle.end_poly()
>>> p = turtle.get_poly()
>>> register_shape("myFavouriteShape", p)
turtle.clone()

Erstelle und gib einen Klon der Turtle mit derselben Position, Ausrichtung und denselben Turtle-Eigenschaften zurück.

>>> leonel = Turtle()
>>> marco = leonel.clone()
turtle.getturtle()
turtle.getpen()

Gib das Turtle-Objekt selbst zurück.

Rufe getturtle() auf, um die Turtle zu bekommen, die Funktionen wie forward() und left() verwenden:

>>> pet = getturtle()
>>> pet.fd(50)
>>> pet
<turtle.Turtle object at 0x...>
turtle.getscreen()

Gib das TurtleScreen-Objekt zurück, auf dem die Turtle zeichnet. Für dieses Objekt können dann TurtleScreen-Methoden aufgerufen werden.

>>> ts = turtle.getscreen()
>>> ts
<turtle._Screen object at 0x...>
>>> ts.bgcolor("pink")
turtle.setundobuffer(size)
Parameter:

size – eine Ganzzahl oder None

Setze den Undo-Puffer oder deaktiviere ihn. Ist size eine Ganzzahl, wird ein leerer Undo-Puffer der angegebenen Größe installiert. size gibt die maximale Anzahl der Turtle-Aktionen an, die durch die Methode/Funktion undo() rückgängig gemacht werden können. Ist size None, wird der Undo-Puffer deaktiviert.

>>> turtle.setundobuffer(42)
turtle.undobufferentries()

Gib die Anzahl der Einträge im Undo-Puffer zurück.

>>> while undobufferentries():
...     undo()

Screen-Methoden und -Funktionen

Die meisten Beispiele in diesem Abschnitt beziehen sich auf eine TurtleScreen-Instanz namens screen.

Fenstersteuerung

turtle.bgcolor()
turtle.bgcolor(color, /)
turtle.bgcolor(r, g, b, /)

Gib die Hintergrundfarbe des TurtleScreen zurück oder setze sie.

Vier Eingabeformate sind erlaubt:

bgcolor()

Gib die aktuelle Hintergrundfarbe als Farbangabe-Zeichenkette oder als Tupel zurück (siehe Beispiel). Kann als Eingabe für einen weiteren Aufruf von color(), pencolor(), fillcolor() oder bgcolor() verwendet werden.

bgcolor(colorstring)

Setzt die Hintergrundfarbe auf colorstring, eine Tk-Farbangabe als Zeichenkette, etwa "red", "yellow" oder "#33cc8c".

bgcolor((r, g, b))

Setze die Hintergrundfarbe auf die durch das Tupel aus r, g und b dargestellte RGB-Farbe. Jeder der Werte r, g und b muss im Bereich 0..colormode liegen, wobei colormode entweder 1.0 oder 255 ist (siehe colormode()).

bgcolor(r, g, b)

Setze die Hintergrundfarbe auf die durch r, g und b dargestellte RGB-Farbe. Jeder der Werte r, g und b muss im Bereich 0..colormode liegen.

>>> screen.bgcolor("orange")
>>> screen.bgcolor()
'orange'
>>> screen.bgcolor("#800080")
>>> screen.bgcolor()
(128.0, 0.0, 128.0)
turtle.bgpic(picname=None)
Parameter:

picname – eine Zeichenkette oder None

Set the background image or return the name of the current one. If picname is the name of an image file (PNG, GIF, PGM, and PPM), set that image as the background. If picname is "nopic", delete the background image, if present. If picname is None, return the filename of the current background image.

>>> screen.bgpic()
'nopic'
>>> screen.bgpic("landscape.gif")
>>> screen.bgpic()
'landscape.gif'
turtle.clear()

Bemerkung

Diese TurtleScreen-Methode ist als globale Funktion nur unter dem Namen clearscreen verfügbar. Die globale Funktion clear ist eine andere, die von der Turtle-Methode clear abgeleitet ist.

turtle.clearscreen()

Lösche alle Zeichnungen und alle Turtles vom TurtleScreen. Setze den nun leeren TurtleScreen auf seinen Ausgangszustand zurück: weißer Hintergrund, kein Hintergrundbild, keine Ereignisbindungen und Tracing aktiviert.

turtle.reset()

Bemerkung

Diese TurtleScreen-Methode ist als globale Funktion nur unter dem Namen resetscreen verfügbar. Die globale Funktion reset ist eine andere, die von der Turtle-Methode reset abgeleitet ist.

turtle.resetscreen()

Setze alle Turtles auf dem Screen auf ihren Ausgangszustand zurück.

turtle.screensize(canvwidth=None, canvheight=None, bg=None)
Parameter:

  • canvwidth – eine positive Ganzzahl oder None

  • canvheight – eine positive Ganzzahl oder None

  • bg – a colorstring or a color tuple or None

Resize the canvas the turtles are drawing on. canvwidth and canvheight are the new width and height of the canvas in pixels, and bg is the new background color. If no arguments are given, return the current canvas width and height.

The drawing window is not altered. To see hidden parts of the canvas, use the scrollbars. This can make visible those parts of a drawing which were outside the canvas before, for example to find a turtle that has wandered off the canvas.

>>> screen.screensize()
(400, 300)
>>> screen.screensize(2000,1500)
>>> screen.screensize()
(2000, 1500)
turtle.setworldcoordinates(llx, lly, urx, ury)
Parameter:

  • llx – eine Zahl

  • lly – eine Zahl

  • urx – eine Zahl

  • ury – eine Zahl

Richte ein benutzerdefiniertes Koordinatensystem ein. llx und lly sind die x- und die y-Koordinate der linken unteren Ecke der Leinwand. urx und ury sind die x- und die y-Koordinate der rechten oberen Ecke. Wechselt nötigenfalls in den Modus „world“, was ein Zurücksetzen auslöst. Ist der Modus „world“ schon aktiv, werden alle Zeichnungen gemäß den neuen Koordinaten neu gezeichnet. In benutzerdefinierten Koordinatensystemen können Winkel verzerrt erscheinen, siehe mode().

>>> screen.reset()
>>> screen.setworldcoordinates(-50,-7.5,50,7.5)
>>> for _ in range(72):
...     left(10)
...
>>> for _ in range(8):
...     left(45); fd(2)   # a regular octagon

Animationskontrolle

turtle.no_animation()

Schalte die Turtle-Animation vorübergehend ab. Der Code innerhalb des with-Blocks wird nicht animiert. Sobald der Block verlassen wird, erscheint die Zeichnung. Das ist nützlich, um aufwendige Formen zu zeichnen, bei denen selbst die schnellste Geschwindigkeitseinstellung zu langsam ist.

>>> with screen.no_animation():
...     for dist in range(2, 400, 2):
...         fd(dist)
...         rt(90)

Added in version 3.14.

turtle.delay(delay=None)
Parameter:

delay – eine nichtnegative Ganzzahl oder None

Gib die Zeichenverzögerung in Millisekunden zurück oder setze sie. Das ist ungefähr das Zeitintervall zwischen zwei aufeinanderfolgenden Aktualisierungen der Leinwand. Je länger die Zeichenverzögerung, desto langsamer die Animation.

>>> screen.delay()
10
>>> screen.delay(5)
>>> screen.delay()
5
turtle.tracer(n=None, delay=None)
Parameter:

  • n – eine nichtnegative Ganzzahl oder None

  • delay – eine nichtnegative Ganzzahl oder None

Schalte die Turtle-Animation ein oder aus und setze die Zeichenverzögerung. Wird n angegeben, wird nur jede n-te gewöhnliche Bildschirmaktualisierung ausgeführt, womit sich das Zeichnen aufwendiger Grafiken beschleunigen lässt. Ist n 0, wird die Animation abgeschaltet und der Bildschirm nur noch durch einen Aufruf von update() aktualisiert. Wird delay angegeben, setzt es die Zeichenverzögerung, siehe delay(). Beim Aufruf ohne Argumente wird der aktuelle Wert von n zurückgegeben.

>>> screen.tracer(8, 25)
>>> dist = 2
>>> for i in range(200):
...     fd(dist)
...     rt(90)
...     dist += 2
turtle.update()

Führe eine TurtleScreen-Aktualisierung durch. Zu verwenden, wenn tracer ausgeschaltet ist.

Siehe auch die RawTurtle/Turtle-Methode speed().

Screen-Events verwenden

turtle.listen(xdummy=None, ydummy=None)
Parameter:

  • xdummy – ignored

  • ydummy – ignored

Set focus on the TurtleScreen so that it receives key events. The two dummy arguments are only there so that listen() can be passed to onclick().

turtle.onkey(fun, key)
turtle.onkeyrelease(fun, key)
Parameter:

  • fun – eine Funktion ohne Argumente oder None

  • key – eine Zeichenkette

Bind fun to the key-release event of key. key is a key, such as „a“, or a key symbol, such as „space“. If fun is None, the event binding is removed. To be able to receive key events, the TurtleScreen must have focus, see listen().

>>> def f():
...     fd(50)
...     lt(60)
...
>>> screen.onkey(f, "Up")
>>> screen.listen()

The turtle can then be moved by repeatedly pressing the up-arrow key, drawing a hexagon.

turtle.onkeypress(fun, key=None)
Parameter:

  • fun – eine Funktion ohne Argumente oder None

  • key – eine Zeichenkette oder None

Bind fun to the key-press event of key. key is a key, such as „a“, or a key symbol, such as „space“. If key is not given, fun is bound to the key-press event of any key. If fun is None, the event binding is removed. To be able to receive key events, the TurtleScreen must have focus, see listen().

>>> def f():
...     fd(50)
...     lt(60)
...
>>> screen.onkeypress(f, "Up")
>>> screen.listen()

The turtle can then be moved by pressing or holding down the up-arrow key, drawing a hexagon.

turtle.onclick(fun, btn=1, add=None)
turtle.onscreenclick(fun, btn=1, add=None)
Parameter:

  • fun – eine Funktion mit zwei Argumenten oder None

  • btn – eine Ganzzahl

  • add – ein Wahrheitswert oder None

Binde fun an Mausklick-Ereignisse auf diesem Screen. fun wird mit den Koordinaten des angeklickten Punktes auf der Leinwand aufgerufen. Ist fun None, werden bestehende Bindungen entfernt. btn ist die Nummer der Maustaste und ist standardmäßig 1, die linke Maustaste. Ist add True, wird eine neue Bindung hinzugefügt, andernfalls ersetzt sie eine frühere Bindung.

Beispiel für eine TurtleScreen-Instanz namens screen und eine Turtle-Instanz namens turtle:

>>> screen.onclick(turtle.goto) # Subsequently clicking into the TurtleScreen will
>>>                             # make the turtle move to the clicked point.
>>> screen.onclick(None)        # remove event binding again

Bemerkung

Diese TurtleScreen-Methode ist als globale Funktion nur unter dem Namen onscreenclick verfügbar. Die globale Funktion onclick ist eine andere, die von der Turtle-Methode onclick abgeleitet ist.

turtle.ontimer(fun, t=0)
Parameter:

  • fun – eine Funktion ohne Argumente

  • t – a nonnegative number

Installiere einen Timer, der fun nach t Millisekunden aufruft.

>>> running = True
>>> def f():
...     if running:
...         fd(50)
...         lt(60)
...         screen.ontimer(f, 250)
>>> f()  # makes the turtle march around
>>> running = False
turtle.mainloop()
turtle.done()

Starte die Ereignisschleife, indem die Methode mainloop() von Tkinter aufgerufen wird. Muss die letzte Anweisung in einem Turtle-Grafikprogramm sein. Darf nicht verwendet werden, wenn ein Skript innerhalb von IDLE im Modus -n ausgeführt wird (siehe Running without a subprocess).

Eingabemethoden

turtle.textinput(title, prompt)
Parameter:

  • title – eine Zeichenkette

  • prompt – eine Zeichenkette

Öffne ein Dialogfenster zur Eingabe einer Zeichenkette. title ist der Titel des Dialogfensters, prompt ist ein Text, der beschreibt, welche Information einzugeben ist. Gib die eingegebene Zeichenkette zurück. Wird der Dialog abgebrochen, wird None zurückgegeben.

>>> screen.textinput("NIM", "Name of first player:")
turtle.numinput(title, prompt, default=None, minval=None, maxval=None)
Parameter:

  • title – eine Zeichenkette

  • prompt – eine Zeichenkette

  • default – eine Zahl oder None

  • minval – eine Zahl oder None

  • maxval – eine Zahl oder None

Öffne ein Dialogfenster zur Eingabe einer Zahl. title ist der Titel des Dialogfensters, prompt ist ein Text, der beschreibt, welche Zahlenangabe einzugeben ist. default ist der Standardwert, minval und maxval sind der Mindest- und der Höchstwert für die Eingabe. Sind diese angegeben, muss die eingegebene Zahl zwischen minval und maxval liegen. Ist das nicht der Fall, wird ein Hinweis ausgegeben und der Dialog bleibt zur Korrektur geöffnet. Gib die eingegebene Zahl zurück. Wird der Dialog abgebrochen, wird None zurückgegeben.

>>> screen.numinput("Poker", "Your stakes:", 1000, minval=10, maxval=10000)

Einstellungen und spezielle Methoden

turtle.mode(mode=None)
Parameter:

mode – eine Zeichenkette oder None

Setze den Turtle-Modus und führe ein Zurücksetzen durch. mode ist eine der Zeichenketten „standard“, „logo“ oder „world“. Wird mode nicht angegeben, wird der aktuelle Modus zurückgegeben.

Der Modus „standard“ ist mit dem alten Modul turtle verträglich. Der Modus „logo“ ist mit den meisten Logo-Turtle-Grafiken verträglich. Der Modus „world“ verwendet benutzerdefinierte Weltkoordinaten, siehe setworldcoordinates(). In diesem Modus erscheinen Winkel verzerrt, wenn die x- und die y-Einheit nicht gleich lang sind.

Modus

Anfängliche Ausrichtung der Turtle

positive Winkel

„standard“

nach rechts (Osten)

gegen den Uhrzeigersinn

„logo“

nach oben (Norden)

im Uhrzeigersinn

 
>>> mode("logo")  # resets turtle heading to north
>>> mode()
'logo'
turtle.colormode(cmode=None)
Parameter:

cmode – eine Zahl oder None

Gib den colormode zurück oder setze ihn auf 1.0 oder 255. Nach dem Setzen müssen die Werte r, g und b von Farbtripeln zwischen 0 und cmode liegen.

>>> screen.colormode(1)
>>> turtle.pencolor(240, 160, 80)
Traceback (most recent call last):
     ...
TurtleGraphicsError: bad color sequence: (240, 160, 80)
>>> screen.colormode()
1.0
>>> screen.colormode(255)
>>> screen.colormode()
255
>>> turtle.pencolor(240,160,80)
turtle.getcanvas()

Gib die Canvas dieses TurtleScreen zurück. Nützlich für Insider, die wissen, was mit einer Tkinter-Canvas anzufangen ist.

>>> cv = screen.getcanvas()
>>> cv
<turtle.ScrolledCanvas object ...>
turtle.getshapes()

Gib eine Liste der Namen aller aktuell verfügbaren Turtle-Formen zurück.

>>> screen.getshapes()
['arrow', 'blank', 'circle', ..., 'turtle']
turtle.register_shape(name, shape=None)
turtle.addshape(name, shape=None)
Parameter:

  • name – eine Zeichenkette

  • shape – eine Zeichenkette, ein Tupel aus Zahlenpaaren, ein Shape-Objekt oder None

Füge der Formenliste des TurtleScreen eine Turtle-Form hinzu. Das lässt sich auf vier verschiedene Weisen aufrufen:

  1. name ist der Name einer Bilddatei (PNG, GIF, PGM und PPM) und shape ist None: Installiere die entsprechende Bildform.

    >>> screen.register_shape("turtle.gif")

  2. name ist eine beliebige Zeichenkette und shape ist der Name einer Bilddatei (PNG, GIF, PGM und PPM): Installiere die entsprechende Bildform.

    >>> screen.register_shape("turtle", "turtle.gif")

  3. name ist eine beliebige Zeichenkette und shape ist ein Tupel aus Koordinatenpaaren: Installiere die entsprechende Polygonform.

    >>> screen.register_shape("triangle", ((5,-3), (0,5), (-5,-3)))

  4. name ist eine beliebige Zeichenkette und shape ist ein (zusammengesetztes) Shape-Objekt: Installiere die entsprechende zusammengesetzte Form.

Bildformen drehen sich nicht mit, wenn die Turtle gedreht wird, sie zeigen also nicht die Ausrichtung der Turtle an. Um eine registrierte Form zu verwenden, rufe shape() mit ihrem Namen auf.

Geändert in Version 3.14: Unterstützung für die Bildformate PNG, PGM und PPM hinzugefügt. Es kann sowohl ein Formname als auch ein Bilddateiname angegeben werden.

turtle.turtles()

Gib die Liste der Turtles auf dem Screen zurück.

>>> for turtle in screen.turtles():
...     turtle.color("red")
turtle.window_height()

Gib die Höhe des Turtle-Fensters zurück.

>>> screen.window_height()
480
turtle.window_width()

Gib die Weite des Turtle-Fensters zurück.

>>> screen.window_width()
640

Methoden, die es nur beim Screen gibt

turtle.bye()

Schließe das Turtle-Grafikfenster.

turtle.exitonclick()

Binde die Methode bye() an Mausklicks auf dem Screen.

Ist der Wert „using_IDLE“ im Konfigurations-Dictionary False (Standardwert), wird auch mainloop aufgerufen. Anmerkung: Wird IDLE mit dem Schalter -n (kein Subprozess) verwendet, sollte dieser Wert in turtle.cfg auf True gesetzt werden. In diesem Fall ist IDLEs eigene mainloop auch für das Client-Skript aktiv.

turtle.save(filename, *, overwrite=False)
Parameter:

  • filename – eine Zeichenkette

  • overwrite – Ein Boolean

Save the current drawing and the turtles as a PostScript file. filename is the path of the file to create. It must end with ".ps" or ".eps". If a file with that name already exists, a FileExistsError is raised, unless overwrite is True. overwrite must be given by name, as in overwrite=True.

>>> screen.save("my_drawing.ps")
>>> screen.save("my_drawing.ps", overwrite=True)

Added in version 3.14.

turtle.setup(width=_CFG['width'], height=_CFG['height'], startx=_CFG['leftright'], starty=_CFG['topbottom'])

Setze die Größe und Position des Hauptfensters. Standardwerte der Argumente sind im Konfigurations-Dictionary gespeichert und können über eine turtle.cfg-Datei geändert werden.

Parameter:

  • width – bei einer Ganzzahl eine Größe in Pixeln, bei einer Gleitkommazahl ein Anteil des Bildschirms; Standard ist 50 % des Bildschirms

  • height – bei einer Ganzzahl die Höhe in Pixeln, bei einer Gleitkommazahl ein Anteil des Bildschirms; Standard ist 75 % des Bildschirms

  • startx – bei einem positiven Wert die Startposition in Pixeln vom linken Bildschirmrand aus, bei einem negativen Wert vom rechten Rand aus, bei None wird das Fenster horizontal zentriert

  • starty – bei einem positiven Wert die Startposition in Pixeln vom oberen Bildschirmrand aus, bei einem negativen Wert vom unteren Rand aus, bei None wird das Fenster vertikal zentriert

>>> screen.setup (width=200, height=200, startx=0, starty=0)
>>>              # sets window to 200x200 pixels, in upper left of screen
>>> screen.setup(width=.75, height=0.5, startx=None, starty=None)
>>>              # sets window to 75% of screen by 50% of screen and centers
turtle.title(titlestring)
Parameter:

titlestring – eine Zeichenkette

Setze den Titel des Turtle-Fensters auf titlestring. Der Titel wird in der Titelleiste des Turtle-Grafikfensters angezeigt.

>>> screen.title("Welcome to the turtle zoo!")

Öffentliche Klassen

class turtle.RawTurtle(canvas)
class turtle.RawPen(canvas)
Parameter:

canvas – ein tkinter.Canvas, ein ScrolledCanvas oder ein TurtleScreen

Erstelle eine Turtle. Die Turtle hat alle oben als „Methoden von Turtle/RawTurtle“ beschriebenen Methoden.

class turtle.Turtle

Unterklasse von RawTurtle, hat dieselbe Schnittstelle, zeichnet aber auf einem Standard-Screen-Objekt, das automatisch erstellt wird, wenn es zum ersten Mal benötigt wird.

class turtle.TurtleScreen(cv)
Parameter:

cv – a tkinter.Canvas

Stellt bildschirmorientierte Methoden wie bgcolor() usw. bereit, die oben beschrieben sind.

class turtle.Screen

Unterklasse von TurtleScreen, mit vier zusätzlichen Methoden. Ein Aufruf von Screen() gibt das einzige Screen-Objekt zurück. Existiert es noch nicht, wird es erzeugt. Andernfalls wird das vorhandene zurückgegeben.

class turtle.ScrolledCanvas(master)
Parameter:

master – ein Tkinter-Widget, das den ScrolledCanvas enthält, d. h. ein Tkinter-Canvas mit hinzugefügten Bildlaufleisten

Wird von der Klasse Screen verwendet, die dadurch automatisch einen ScrolledCanvas als Spielfläche für die Turtles bereitstellt.

class turtle.Shape(type_, data)
Parameter:

  • type_ – eine Zeichenkette

  • data – hängt von type_ ab

Datenstruktur, die Formen nachbildet. type_ ist eine der Zeichenketten „polygon“, „image“ oder „compound“. Was data sein muss, hängt von type_ ab: bei „polygon“ ein Tupel aus Koordinatenpaaren, bei „image“ ein Bild (wird nur intern verwendet) und bei „compound“ None, weil eine zusammengesetzte Form über die Methode addcomponent() aufgebaut wird.

addcomponent(poly, fill, outline=None)
Parameter:

  • poly – ein Tupel aus Zahlenpaaren

  • fill – eine Farbe

  • outline – eine Farbe oder None

Füge einer Form des Typs „compound“ eine Komponente hinzu. poly ist ein Polygon, ein Tupel aus Zahlenpaaren. fill ist die Farbe, mit der das Polygon gefüllt wird, und outline ist die Farbe seines Umrisses. Wird outline nicht angegeben, wird dafür ebenfalls fill verwendet.

Beispiel:

>>> poly = ((0,0), (10,-5), (0,10), (-10,-5))
>>> s = Shape("compound")
>>> s.addcomponent(poly, "red", "blue")
>>> # ... add more components and then use register_shape()

Siehe Zusammengesetzte Formen verwenden.

class turtle.Vec2D(x, y)

Eine zweidimensionale Vektorklasse, die als Hilfsklasse zur Implementierung von Turtle-Grafik dient. Kann auch für Turtle-Grafik-Programme selbst nützlich sein. Von tuple abgeleitet, ein Vektor ist also ein Tupel!

Bietet (für Vektoren a, b, Zahl k):

  • a + b Vectoraddition

  • a - b Vectorsubtraction

  • a * b Skalarprodukt

  • k * a und a * k Multiplikation mit Skalar

  • abs(a) Absolutwert von a

  • a.rotate(angle) Rotation

Erklärungen

Das Modul turtle definiert die folgende Ausnahme:

exception turtle.TurtleGraphicsError

Wird bei ungültigen Argumenten oder Operationen ausgelöst. Zum Beispiel bei einer fehlerhaften Farbzeichenkette:

>>> turtle.color("blau")
Traceback (most recent call last):
    ...
turtle.TurtleGraphicsError: bad color string: blau

How-to-Anleitungen

Dieser Abschnitt behandelt einige typische Anwendungsfälle und Vorgehensweisen für Turtle.

Füllen automatisch beginnen und beenden

Ab Python 3.14 kannst du den Kontextmanager fill() anstelle von begin_fill() und end_fill() verwenden, um das Füllen automatisch zu beginnen und zu beenden. Hier ist ein Beispiel:

with fill():
    for i in range(4):
        forward(100)
        right(90)

forward(200)

Der obige Code ist äquivalent zu:

begin_fill()
for i in range(4):
    forward(100)
    right(90)
end_fill()

forward(200)

Zusammengesetzte Formen verwenden

Um zusammengesetzte Turtle-Formen zu verwenden, die aus mehreren Polygonen unterschiedlicher Farbe bestehen, musst du die Hilfsklasse Shape explizit verwenden, wie unten beschrieben:

  1. Erstelle ein leeres Shape-Objekt vom Typ „compound“.

  2. Füge diesem Objekt beliebig viele Komponenten hinzu, indem du die Methode addcomponent() verwendest.

    Zum Beispiel:

    >>> s = Shape("compound")
>>> poly1 = ((0,0), (10,-5), (0,10), (-10,-5))
>>> s.addcomponent(poly1, "red", "blue")
>>> poly2 = ((0,0), (10,-5), (-10,-5))
>>> s.addcomponent(poly2, "blue", "red")

  3. Füge nun die Shape zur Formenliste des Screens hinzu und verwende sie:

    >>> register_shape("myshape", s)
>>> shape("myshape")

Das turtle-Modul im eigenen Namensraum verwenden

Es ist praktisch, from turtle import * zu verwenden – aber sei gewarnt, dass dadurch eine recht große Sammlung von Objekten importiert wird, und wenn du irgendetwas außer Turtle-Grafik machst, läufst du Gefahr eines Namenskonflikts (dies wird noch problematischer, wenn du Turtle-Grafik in einem Skript verwendest, in dem auch andere Module importiert werden könnten).

Die Lösung besteht darin, import turtle zu verwenden - fd() wird zu turtle.fd(), width() wird zu turtle.width() und so weiter. (Falls es lästig wird, immer wieder „turtle“ zu tippen, verwende stattdessen zum Beispiel import turtle as t.)

Turtle-Grafik in einem Skript verwenden

Es wird empfohlen, den Namensraum des Moduls turtle wie unmittelbar oben beschrieben zu verwenden, zum Beispiel:

import turtle as t
from random import random

for i in range(100):
    steps = int(random() * 100)
    angle = int(random() * 360)
    t.right(angle)
    t.fd(steps)

Ein weiterer Schritt ist jedoch ebenfalls erforderlich - sobald das Skript endet, wird Python auch das Fenster der Turtle schließen. Füge Folgendes hinzu:

t.mainloop()

am Ende des Skripts. Das Skript wartet nun darauf, geschlossen zu werden, und beendet sich nicht, bis es beendet wird, zum Beispiel durch Schließen des Turtle-Grafikfensters.

Objektorientierte Turtle-Grafik verwenden

Siehe auch

Erklärung der objektorientierten Schnittstelle

Abgesehen von sehr grundlegenden Einführungszwecken oder um Dinge so schnell wie möglich auszuprobieren, ist es üblicher und deutlich leistungsfähiger, den objektorientierten Ansatz für Turtle-Grafik zu verwenden. Dies ermöglicht zum Beispiel mehrere Turtles gleichzeitig auf dem Bildschirm.

Bei diesem Ansatz sind die verschiedenen Turtle-Befehle Methoden von Objekten (meist von Turtle-Objekten). Du kannst den objektorientierten Ansatz auch in der Shell verwenden, typischer wäre es aber in einem Python-Skript.

Das obige Beispiel wird dann zu:

from turtle import Turtle
from random import random

t = Turtle()
for i in range(100):
    steps = int(random() * 100)
    angle = int(random() * 360)
    t.right(angle)
    t.fd(steps)

t.screen.mainloop()

Beachte die letzte Zeile. t.screen ist eine Instanz der Screen, auf der eine Turtle-Instanz existiert. Sie wird automatisch zusammen mit der Turtle erstellt.

Der Turtle-Scree kann angepasst werden, zum Beispiel:

t.screen.title('Object-oriented turtle demo')
t.screen.bgcolor("orange")

Wie man help() verwendet

Die öffentlichen Methoden der Klassen Screen und Turtle sind ausführlich über Docstrings dokumentiert. Diese können daher über die Python-Hilfefunktionen als Online-Hilfe verwendet werden:

  • Bei Verwendung von IDLE zeigen Tooltips die Signaturen und die ersten Zeilen der Docstrings eingetippter Funktions-/Methodenaufrufe.

  • Der Aufruf von help() für Methoden oder Funktionen zeigt die Docstrings an:

    >>> help(Screen.bgcolor)
Help on method bgcolor in module turtle:

bgcolor(self, *args) unbound turtle.Screen method
    Set or return backgroundcolor of the TurtleScreen.

    Arguments (if given): a color string or three numbers
    in the range 0..colormode or a 3-tuple of such numbers.


    >>> screen.bgcolor("orange")
    >>> screen.bgcolor()
    "orange"
    >>> screen.bgcolor(0.5,0,0.5)
    >>> screen.bgcolor()
    "#800080"

>>> help(Turtle.penup)
Help on method penup in module turtle:

penup(self) unbound turtle.Turtle method
    Pull the pen up -- no drawing when moving.

    Aliases: penup | pu | up

    No argument

    >>> turtle.penup()

  • Die Docstrings der Funktionen, die von Methoden abgeleitet sind, haben eine abgewandelte Form:

    >>> help(bgcolor)
Help on function bgcolor in module turtle:

bgcolor(*args)
    Set or return backgroundcolor of the TurtleScreen.

    Arguments (if given): a color string or three numbers
    in the range 0..colormode or a 3-tuple of such numbers.

    Example::

      >>> bgcolor("orange")
      >>> bgcolor()
      "orange"
      >>> bgcolor(0.5,0,0.5)
      >>> bgcolor()
      "#800080"

>>> help(penup)
Help on function penup in module turtle:

penup()
    Pull the pen up -- no drawing when moving.

    Aliases: penup | pu | up

    No argument

    Example:
    >>> penup()

Diese abgewandelten Docstrings werden automatisch zusammen mit den Funktionsdefinitionen erstellt, die zur Importzeit von den Methoden abgeleitet werden.

Übersetzung von Docstrings in verschiedene Sprachen

Es gibt ein Hilfsprogramm, um ein Dictionary zu erstellen, dessen Schlüssel die Methodennamen und dessen Werte die Docstrings der öffentlichen Methoden der Klassen Screen und Turtle sind.

turtle.write_docstringdict(filename='turtle_docstringdict')
Parameter:

filename – eine Zeichenkette, verwendet als Dateiname

Erstelle das Docstring-Dictionary und schreibe es in ein Python-Skript mit dem angegebenen Dateinamen. Diese Funktion muss explizit aufgerufen werden (sie wird nicht von den Turtle-Grafik-Klassen verwendet). Das Docstring-Dictionary wird in das Python-Skript filename.py geschrieben. Es ist als Vorlage für die Übersetzung der Docstrings in verschiedene Sprachen gedacht.

Wenn du (oder deine Lernenden) turtle mit Online-Hilfe in deiner Muttersprache verwenden möchtest, musst du die Docstrings übersetzen und die entstehende Datei z. B. als turtle_docstringdict_german.py speichern.

Wenn du einen entsprechenden Eintrag in deiner turtle.cfg-Datei hast, wird dieses Dictionary zur Importzeit eingelesen und ersetzt die ursprünglichen englischen Docstrings.

Zum Zeitpunkt der Erstellung dieses Textes gibt es Docstring-Dictionaries auf Deutsch und auf Italienisch. (Anfragen bitte an glingl@aon.at.)

Wie man Screen und Turtles konfiguriert

Die integrierte Standardkonfiguration ahmt das Erscheinungsbild und Verhalten des alten turtle-Moduls nach, um eine möglichst gute Kompatibilität damit zu bewahren.

Wenn du eine andere Konfiguration verwenden möchtest, die die Funktionen dieses Moduls besser widerspiegelt oder besser zu deinen Bedürfnissen passt, z. B. für den Einsatz im Unterricht, kannst du eine Konfigurationsdatei turtle.cfg vorbereiten, die zur Importzeit eingelesen wird und die Konfiguration entsprechend ihrer Einstellungen ändert.

Die integrierte Konfiguration würde der folgenden turtle.cfg entsprechen:

width = 0.5
height = 0.75
leftright = None
topbottom = None
canvwidth = 400
canvheight = 300
mode = standard
colormode = 1.0
delay = 10
undobuffersize = 1000
shape = classic
pencolor = black
fillcolor = black
resizemode = noresize
visible = True
language = english
exampleturtle = turtle
examplescreen = screen
title = Python Turtle Graphics
using_IDLE = False

Kurze Erklärung ausgewählter Einträge:

  • Die ersten vier Zeilen entsprechen den Argumenten der Methode Screen.setup.

  • Zeile 5 und 6 entsprechen den Argumenten der Methode Screen.screensize.

  • shape kann eine der integrierten Formen sein, z. B.: arrow, turtle usw. Für weitere Informationen versuche help(shape).

  • Wenn du keine Füllfarbe verwenden möchtest (d. h. die Turtle transparent machen möchtest), musst du fillcolor = "" schreiben (aber alle nichtleeren Zeichenketten dürfen in der cfg-Datei keine Anführungszeichen haben).

  • Wenn die Turtle ihren Zustand widerspiegeln soll, musst du resizemode = auto verwenden.

  • Wenn du z.B. language = italian setzt, wird das docstringdict turtle_docstringdict_italian.py zur Importzeit geladen (sofern es im Importpfad vorhanden ist, z. B. im selben Verzeichnis wie turtle).

  • Die Einträge exampleturtle und examplescreen legen die Namen dieser Objekte fest, wie sie in den Docstrings vorkommen. Bei der Umwandlung von Methoden-Docstrings in Funktions-Docstrings werden diese Namen aus den Docstrings entfernt.

  • using_IDLE: Setze dies auf True, wenn du regelmäßig mit IDLE und dessen Schalter -n („no subprocess“) arbeitest. Dies verhindert, dass exitonclick() die mainloop aufruft.

Es kann eine turtle.cfg-Datei im Verzeichnis geben, in dem turtle gespeichert ist, sowie eine zusätzliche im aktuellen Arbeitsverzeichnis. Letztere überschreibt die Einstellungen der ersten.

Das Verzeichnis Lib/turtledemo enthält eine turtle.cfg-Datei. Du kannst sie als Beispiel studieren und ihre Auswirkungen beim Ausführen der Demos sehen (vorzugsweise nicht innerhalb des Demo-Viewers).

Erklärung

Ein Turtle-Objekt zeichnet auf einem Screen-Objekt, und es gibt eine Reihe zentraler Klassen in der objektorientierten Turtle-Schnittstelle, mit denen man diese erstellen und miteinander in Beziehung setzen kann.

Eine Turtle-Instanz erstellt automatisch eine Screen-Instanz, falls noch keine vorhanden ist.

Turtle ist eine Unterklasse von RawTurtle, die keine Zeichenfläche automatisch erstellt - eine canvas muss dafür bereitgestellt oder erstellt werden. Die canvas kann ein tkinter.Canvas, ScrolledCanvas oder TurtleScreen sein.

TurtleScreen ist die grundlegende Zeichenfläche für eine Turtle. Screen ist eine Unterklasse von TurtleScreen und enthält einige zusätzliche Methoden zur Verwaltung ihres Erscheinungsbilds (einschließlich Größe und Titel) und Verhaltens. Der Konstruktor von TurtleScreen benötigt ein tkinter.Canvas oder ein ScrolledCanvas als Argument.

Die funktionale Schnittstelle für Turtle-Grafik verwendet die verschiedenen Methoden von Turtle und TurtleScreen/Screen. Im Hintergrund wird automatisch ein Screen-Objekt erstellt, sobald eine von einer Screen-Methode abgeleitete Funktion aufgerufen wird. Ebenso wird automatisch ein Turtle-Objekt erstellt, sobald eine der von einer Turtle-Methode abgeleiteten Funktionen aufgerufen wird.

Um mehrere Turtles auf einem Screen zu verwenden, muss die objektorientierte Schnittstelle genutzt werden.

turtledemo — Demo-Skripte

Das Paket turtledemo enthält eine Reihe von Demo-Skripten. Diese Skripte können mit dem mitgelieferten Demo-Viewer wie folgt ausgeführt und betrachtet werden:

python -m turtledemo

Alternativ kannst du die Demo-Skripte auch einzeln ausführen. Zum Beispiel:

python -m turtledemo.bytedesign

Das Paketverzeichnis turtledemo enthält:

  • Einen Demo-Viewer __main__.py, mit dem der Quellcode der Skripte betrachtet und gleichzeitig ausgeführt werden kann.

  • Mehrere Skripte, die verschiedene Funktionen des Moduls turtle demonstrieren. Auf die Beispiele kann über das Menü Examples zugegriffen werden. Sie können auch eigenständig ausgeführt werden.

  • Eine turtle.cfg-Datei, die als Beispiel dient, wie solche Dateien geschrieben und verwendet werden.

Die Demo-Skripte sind:

Name

Beschreibung

Feature

bytedesign

komplexes klassisches Turtle-Grafik-Muster

tracer(), delay(), update()

chaos

stellt die Verhulst-Dynamik grafisch dar und zeigt, dass Computerberechnungen manchmal Ergebnisse liefern können, die dem gesunden Menschenverstand widersprechen

Welt Koordinaten

clock

analoge Uhr, die die Zeit deines Computers anzeigt

Turtles als Uhrzeiger, ontimer()

colormixer

Experiment mit r, g, b

ondrag()

forest

3 Breitensuche-Bäume

Zufallsgenerierung

fractalcurves

Hilbert & Koch Kurven

Rekursion

lindenmayer

Ethnomathematik (indische Kolams)

L-System

minimal_hanoi

Türme von Hannoi

Rechteckige Turtles als Hanoi-Scheiben (shape(), shapesize())

nim

spiele das klassische Nim-Spiel mit drei Stapeln aus Stäbchen gegen den Computer.

Turtles als Nim-Stäbchen, ereignisgesteuert (Maus, Tastatur)

paint

super minimalistisches Zeichenprogramm

onclick()

peace

Elementar

Turtle: Erscheinungsbild und Animation

penrose

aperiodische Kachelung mit Drachen und Pfeilen

stamp()

planet_and_moon

Simulation eines Gravitationssystems

zusammengesetzte Formen, Vec2D

rosette

ein Muster aus dem Wikipedia-Artikel über Turtle-Grafik

clone(), undo()

round_dance

tanzende Turtles, die sich paarweise in entgegengesetzter Richtung drehen

zusammengesetzte Formen, clone() shapesize(), tilt(), get_shapepoly(), update()

sorting_animate

visuelle Demonstration verschiedener Sortiermethoden

einfache Ausrichtung, Zufallsgenerierung

tree

ein (grafischer) Breitensuche-Baum (unter Verwendung von Generatoren)

clone()

two_canvases

einfaches Design

Turtles auf zwei Canvas

yinyang

ein weiteres elementares Beispiel

circle()

Viel Spaß!