turtle — Turtle-Grafik

Quellcode: Lib/turtle.py

---

Turtle star

Turtle kann komplizierte Formen zeichnen, indem es Programme verwendet, die einfache Bewegungen wiederholen.

Imagine a robotic turtle starting at (0, 0) in the x-y plane. After an import turtle, give it the command turtle.forward(15), and it moves (on-screen!) 15 pixels in the direction it is facing, drawing a line as it moves. Give it the command turtle.right(25), and it rotates in-place 25 degrees clockwise.

Turtle graphics is an implementation of the drawing tools introduced in Logo in 1967. It was created as an educational tool, and its instant, visible feedback makes it an effective way for learners to encounter programming concepts. It is also a convenient way to produce simple graphical output without bringing in external libraries.

This document includes four main sections:

• Tutorial teaches the basics of turtle drawing.

• Reference describes the functions, methods and classes this module defines.

• How-to guides detail how to handle specific tasks.

• Erklärung provides background on the object-oriented interface.

Bemerkung

Turtle graphics requires the tkinter optional module. The python.org installers for Windows and macOS include it, but some Linux distributions and other platforms may package it separately. If import turtle fails with an error mentioning _tkinter, look for documentation from your distributor (that is, whoever provided Python to you). Check this in advance if you’re planning to use turtle graphics with a learner.

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 No module named '_tkinter' stößt, musst du das Tk-Interface-Paket auf deinem System installieren.

Einfaches Zeichnen

Schicke die Turtle 100 Schritte vorwärts:

forward(100)

Du solltest (höchstwahrscheinlich in einem neuen Fenster auf deinem Bildschirm) 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.

Experiment with those commands, and also with backward() and right(). Many commands also have shorter aliases, such as fd() for 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.)

Reference

Turtle methods and functions

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

Move the turtle backward by distance, opposite to the direction the turtle is headed. The turtle’s heading does not change.

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

Turn the turtle right by the specified angle. The angle is measured in degrees by default; the unit can be changed with degrees() or radians(). How the heading is measured depends on the turtle mode, see mode().

>>> turtle.heading()
22.0
>>> turtle.right(45)
>>> turtle.heading()
337.0

turtle.left(angle)

turtle.lt(angle)

Parameter:

angle – eine Zahl

Turn the turtle left by the specified angle. The angle is measured in degrees by default; the unit can be changed with degrees() or radians(). How the heading is measured depends on the turtle mode, see 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

Move the turtle to an absolute position. If y is None, x must be a pair of coordinates or a Vec2D, for example as returned by pos(). If the pen is down, a line is drawn. The turtle’s heading does not change.

>>> 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, y=None, *, fill_gap=False)

Parameter:

• x – eine Zahl oder None

• y – eine Zahl oder None

• fill_gap – Ein Boolean

Bewege die Turtle zu einer absoluten Position. Im Gegensatz zu goto(x, y) wird dabei keine Linie gezeichnet. Die Ausrichtung der Turtle ändert sich nicht. Falls gerade gefüllt wird, wird das Polygon, von dem aus teleportiert wurde, nach dem Verlassen gefüllt, und das Füllen beginnt nach dem Teleportieren erneut. Dies kann mit fill_gap=True deaktiviert werden, wodurch die gedachte Linie, die während des Teleportierens zurückgelegt wird, wie bei goto(x, y) als Füllbarriere wirkt.

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

Set the turtle’s x coordinate to x. The y coordinate is unchanged.

>>> turtle.position()
(0.00,240.00)
>>> turtle.setx(10)
>>> turtle.position()
(10.00,240.00)

turtle.sety(y)

Parameter:

y – eine Zahl

Set the turtle’s y coordinate to y. The x coordinate is unchanged.

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

Set the turtle’s heading to to_angle. Here are some common directions in degrees:

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()

Move the turtle to the origin, coordinates (0,0). The turtle’s heading is set to its start orientation, which depends on the turtle mode, see 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

Draw a circle with the given radius. The center is radius units left of the turtle; extent, an angle, determines which part of the circle is drawn. If extent is not given, draw the entire circle. If extent is not a full circle, one endpoint of the arc is the current pen position. Draw the arc in counterclockwise direction if radius is positive, otherwise in clockwise direction. Finally, the turtle’s heading is changed by extent.

As the circle is approximated by an inscribed regular polygon, steps determines the number of steps to use. If not given, it will be calculated automatically. May be used to draw regular polygons.

>>> 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 Ganzzahl >= 1 (falls angegeben)

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

>>> 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()

Stemple eine Kopie der Turtle-Form an die aktuelle Position der Turtle auf die Zeichenfläche. Gibt eine stamp_id für diesen Stempel zurück, mit der er durch Aufruf von clearstamp(stamp_id) wieder gelöscht werden kann.

>>> turtle.color("blue")
>>> stamp_id = turtle.stamp()
>>> turtle.fd(50)

turtle.clearstamp(stampid)

Parameter:

stampid – eine Ganzzahl, muss der Rückgabewert eines vorherigen Aufrufs von stamp() sein

Lösche den Stempel mit der angegebenen stampid.

>>> 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)

Lösche alle oder die ersten/letzten n Stempel der Turtle. Wenn n None ist, werden alle Stempel gelöscht, wenn n > 0 ist, werden die ersten n Stempel gelöscht, andernfalls, wenn n < 0 ist, werden die letzten n Stempel gelöscht.

>>> 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 im Bereich 0..10 oder ein speedstring (siehe unten)

Setze die Geschwindigkeit der Turtle auf einen Ganzzahlwert im Bereich 0..10. Wird kein Argument angegeben, wird die aktuelle Geschwindigkeit zurückgegeben.

Ist die Eingabe eine Zahl größer als 10 oder kleiner als 0,5, wird die Geschwindigkeit auf 0 gesetzt. Speedstrings werden wie folgt auf Speedvalues abgebildet:

• „fastest“: 0

• „fast“: 10

• „normal“: 6

• „slow“: 3

• „slowest“: 1

Geschwindigkeiten von 1 bis 10 erzwingen eine zunehmend schnellere Animation beim Linienzeichnen und Drehen der Turtle.

Achtung: speed = 0 bedeutet, dass keine Animation stattfindet. forward/back lässt die Turtle springen, und ebenso lassen left/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()

Return the turtle’s current location (x,y) as a Vec2D vector.

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

Return the angle of the line from the turtle’s position to (x,y). If y is None, x must be a pair of coordinates, a Vec2D, for example as returned by pos(), or another turtle. The angle is measured from the turtle’s start orientation, which depends on the turtle mode, see 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()

Return the turtle’s current heading. The value depends on the turtle mode, see 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

Return the distance from the turtle to (x,y) in turtle step units. If y is None, x must be a pair of coordinates, a Vec2D, for example as returned by pos(), or another 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

Set the angle measurement units to degrees. The number of degrees in a full circle is set to fullcircle, which defaults to 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()

Set the angle measurement units to radians. Equivalent to 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 – zeichnet beim Bewegen.

turtle.penup()

turtle.pu()

turtle.up()

Hebe den Stift – zeichnet nicht beim Bewegen.

turtle.pensize(width=None)

turtle.width(width=None)

Parameter:

width – eine positive Zahl

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

>>> turtle.pensize()
1
>>> turtle.pensize(10)   # from here on lines of width 10 are drawn

turtle.pen(pen=None, **pendict)

Parameter:

• pen – ein Dictionary mit einigen oder allen der unten aufgeführten Schlüssel

• pendict – ein oder mehrere Schlüsselwortargumente mit den unten aufgeführten Schlüsseln als Schlüsselwörter

Gib die Attribute des Stifts in einem „Stift-Dictionary“ zurück oder setze sie, mit den folgenden Schlüssel/Wert-Paaren:

• „shown“: True/False

• „pendown“: True/False

• „pencolor“: Farbstring oder Farb-Tupel

• „fillcolor“: Farbstring oder Farb-Tupel

• „pensize“: positive Zahl

• „speed“: Zahl im Bereich 0..10

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

• „stretchfactor“: (positive Zahl, positive Zahl)

• „outline“: positive Zahl

• „tilt“: Zahl

Dieses Dictionary kann als Argument für einen nachfolgenden Aufruf von pen() verwendet werden, um den vorherigen Stiftzustand wiederherzustellen. Außerdem können ein oder mehrere dieser Attribute als Schlüsselwortargumente angegeben werden. Dies kann verwendet werden, um mehrere Stiftattribute in einer einzigen Anweisung zu setzen.

>>> turtle.pen(fillcolor="black", pencolor="red", pensize=10)
>>> sorted(turtle.pen().items())
[('fillcolor', 'black'), ('outline', 1), ('pencolor', 'red'),
 ('pendown', True), ('pensize', 10), ('resizemode', 'noresize'),
 ('shearfactor', 0.0), ('shown', True), ('speed', 9),
 ('stretchfactor', (1.0, 1.0)), ('tilt', 0.0)]
>>> penstate=turtle.pen()
>>> turtle.color("yellow", "")
>>> turtle.penup()
>>> sorted(turtle.pen().items())[:3]
[('fillcolor', ''), ('outline', 1), ('pencolor', 'yellow')]
>>> turtle.pen(penstate, fillcolor="green")
>>> sorted(turtle.pen().items())[:3]
[('fillcolor', 'green'), ('outline', 1), ('pencolor', 'red')]

turtle.isdown()

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

>>> turtle.pensize()
1
>>> turtle.pensize(10)   # from here on lines of width 10 are drawn

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-String oder als Tupel zurück (siehe Beispiel). Kann als Eingabe für einen weiteren color/pencolor/fillcolor/bgcolor-Aufruf 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-String zurück, möglicherweise im Tupel-Format (siehe Beispiel). Kann als Eingabe für einen weiteren color/pencolor/fillcolor/bgcolor-Aufruf 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 den Füllstatus zurück (True, wenn gefüllt wird, sonst False).

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

turtle.begin_fill()

Muss unmittelbar vor dem Zeichnen einer zu füllenden Form aufgerufen werden.

turtle.end_fill()

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

Ob Überlappungsbereiche bei selbstüberschneidenden Polygonen oder mehreren Formen gefüllt werden, hängt von der Grafik des Betriebssystems, der Art der Überlappung und der Anzahl der Überlappungen ab. Zum Beispiel kann der oben gezeigte Turtle-Stern entweder komplett gelb sein oder einige weiße Bereiche aufweisen.

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

Mehr Zeichenkontrolle

turtle.reset()

Lösche die Zeichnungen der Turtle vom Bildschirm, zentriere die Turtle neu und setze die Variablen auf ihre Standardwerte zurück.

>>> 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, zentriere die Turtle neu und setze die Variablen auf ihre Standardwerte zurück.

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

Parameter:

• arg – Objekt, das auf den TurtleScreen geschrieben werden soll

• move – True/False

• align – eine der Zeichenketten „left“, „center“ oder „right“

• font – ein Tripel (fontname, fontsize, fonttype)

Schreibe Text – die String-Darstellung von arg – an die aktuelle Position der Turtle entsprechend align („left“, „center“ oder „right“) und mit der angegebenen Schriftart. Ist move wahr, wird der Stift an die untere rechte Ecke des Textes bewegt. Standardmäßig ist move False.

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

Turtle-Status

Sichtbarkeit

turtle.hideturtle()

turtle.ht()

Mache die Turtle unsichtbar. Es ist eine gute Idee, dies während einer komplexen Zeichnung zu tun, da das Verstecken der Turtle das Zeichnen merklich beschleunigt.

>>> turtle.hideturtle()

turtle.showturtle()

turtle.st()

Mache die Turtle sichtbar.

>>> turtle.showturtle()

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, die ein gültiger Formname ist

Setze die Form der Turtle auf die Form mit dem angegebenen name, oder, falls kein Name angegeben ist, gib den Namen der aktuellen Form zurück. Die Form mit name muss im Formen-Dictionary des TurtleScreen vorhanden sein. Anfangs stehen folgende Polygonformen zur Verfügung: „arrow“, „turtle“, „circle“, „square“, „triangle“, „classic“. Um mehr über den Umgang mit Formen zu erfahren, siehe die Screen-Methode register_shape().

>>> turtle.shape()
'classic'
>>> turtle.shape("turtle")
>>> turtle.shape()
'turtle'

turtle.resizemode(rmode=None)

Parameter:

rmode – eine der Zeichenketten „auto“, „user“, „noresize“

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

• „auto“: passt das Erscheinungsbild der Turtle entsprechend dem Wert von pensize an.

• „user“: passt das Erscheinungsbild der Turtle gemäß den Werten von stretchfactor und outlinewidth (outline) an, die durch shapesize() gesetzt werden.

• „noresize“: es findet keine Anpassung des Erscheinungsbilds der Turtle statt.

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 – Positive Zahl

• stretch_len – Positive Zahl

• outline – Positive Zahl

Gib die Stift-Attribute x/y-Streckfaktoren und/oder outline zurück oder setze sie. Setze resizemode auf „user“. Nur wenn resizemode auf „user“ gesetzt ist, wird die Turtle entsprechend ihrer Streckfaktoren gestreckt dargestellt: stretch_wid ist der Streckfaktor senkrecht zu ihrer Ausrichtung, stretch_len ist der Streckfaktor in Richtung ihrer Ausrichtung, outline bestimmt die Breite des Umrisses der Form.

>>> 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 – Zahl (optional)

Setze den aktuellen Scherfaktor oder gib ihn zurück. Schere die Form der Turtle gemäß dem angegebenen Scherfaktor shear, der der Tangens des Scherwinkels ist. Ändere nicht die Ausrichtung der Turtle (Bewegungsrichtung). Wird shear nicht angegeben: gib den aktuellen Scherfaktor zurück, d. h. den Tangens des Scherwinkels, um den Linien parallel zur Ausrichtung der Turtle geschert werden.

>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.shearfactor(0.5)
>>> turtle.shearfactor()
0.5

turtle.tilt(angle)

Parameter:

angle – eine Zahl

Drehe die Form der Turtle um angle von ihrem aktuellen Kippwinkel aus, ändere aber nicht die Ausrichtung der Turtle (Bewegungsrichtung).

>>> 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 (optional)

Setze den aktuellen Kippwinkel oder gib ihn zurück. Wird angle angegeben, wird die Form der Turtle so gedreht, dass sie in die durch angle angegebene Richtung zeigt, unabhängig von ihrem aktuellen Kippwinkel. Ändere nicht die Ausrichtung der Turtle (Bewegungsrichtung). Wird angle nicht angegeben: gib den aktuellen Kippwinkel zurück, d. h. den Winkel zwischen der Ausrichtung der Form der Turtle und der Ausrichtung der Turtle (ihrer Bewegungsrichtung).

>>> 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 (optional)

• t12 – eine Zahl (optional)

• t21 – eine Zahl (optional)

• t12 – eine Zahl (optional)

Setze die aktuelle Transformationsmatrix der Turtle-Form oder gib sie zurück.

Werden keine der Matrixelemente angegeben, wird die Transformationsmatrix als Tupel aus 4 Elementen zurückgegeben. Andernfalls werden die angegebenen Elemente gesetzt und die Form der Turtle entsprechend der Matrix transformiert, die aus der ersten Zeile t11, t12 und der zweiten Zeile t21, t22 besteht. Die Determinante t11 * t22 - t12 * t21 darf nicht null sein, andernfalls wird ein Fehler ausgelöst. Ändert stretchfactor, shearfactor und tiltangle entsprechend der angegebenen Matrix.

>>> 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()

Gib das aktuelle Formen-Polygon als Tupel von Koordinatenpaaren zurück. Dies kann verwendet werden, um eine neue Form oder Komponenten einer zusammengesetzten Form zu definieren.

>>> 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, 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 Mausklick-Ereignisse dieser Turtle. Ist fun None, werden bestehende Bindungen entfernt. Beispiel für die anonyme Turtle, d. h. die prozedurale Vorgehensweise:

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

>>> mick = Turtle()
>>> joe = mick.clone()

turtle.getturtle()

turtle.getpen()

Gib das Turtle-Objekt selbst zurück. Einzig sinnvolle Verwendung: als Funktion, um die „anonyme Turtle“ zurückzugeben:

>>> 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()

Zusammengesetzte Formen

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

Bemerkung

Die Klasse Shape wird von der Methode register_shape() intern auf unterschiedliche Weise verwendet. Programmierende müssen sich mit der Shape-Klasse nur dann befassen, wenn zusammengesetzte Formen wie oben gezeigt verwendet werden!

Screen methods and functions

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-String oder als Tupel zurück (siehe Beispiel). Kann als Eingabe für einen weiteren color/pencolor/fillcolor/bgcolor-Aufruf verwendet werden.

bgcolor(colorstring)

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

bgcolor((r, g, b))

Setzt die Hintergrundfarbe auf die RGB-Farbe, die durch das Tupel aus r, g und b dargestellt wird. 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 – a string, name of a gif-file or "nopic", or None

Setze das Hintergrundbild oder gib den Namen des aktuellen Hintergrundbilds zurück. Ist picname ein Dateiname, wird das entsprechende Bild als Hintergrund gesetzt. Ist picname "nopic", wird das Hintergrundbild gelöscht, falls vorhanden. Ist picname None, wird der Dateiname des aktuellen Hintergrundbilds zurückgegeben.

>>> 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 – positive Ganzzahl, neue Breite der Zeichenfläche in Pixeln

• canvheight – positive Ganzzahl, neue Höhe der Zeichenfläche in Pixeln

• bg – Farbstring oder Farb-Tupel, neue Hintergrundfarbe

Werden keine Argumente angegeben, wird das aktuelle (canvaswidth, canvasheight) zurückgegeben. Andernfalls wird die Zeichenfläche, auf der die Turtles zeichnen, in der Größe verändert. Das Zeichenfenster wird dabei nicht verändert. Um verborgene Teile der Zeichenfläche zu betrachten, verwende die Bildlaufleisten. Mit dieser Methode können Teile einer Zeichnung sichtbar gemacht werden, die zuvor außerhalb der Zeichenfläche lagen.

>>> screen.screensize()
(400, 300)
>>> screen.screensize(2000,1500)
>>> screen.screensize()
(2000, 1500)

e.g. to search for an erroneously escaped turtle ;-)

turtle.setworldcoordinates(llx, lly, urx, ury)

Parameter:

• llx – eine Zahl, x-Koordinate der unteren linken Ecke der Zeichenfläche

• lly – eine Zahl, y-Koordinate der unteren linken Ecke der Zeichenfläche

• urx – eine Zahl, x-Koordinate der oberen rechten Ecke der Zeichenfläche

• ury – eine Zahl, y-Koordinate der oberen rechten Ecke der Zeichenfläche

Richte ein benutzerdefiniertes Koordinatensystem ein und wechsle bei Bedarf in den Modus „world“. Dies führt ein screen.reset() aus. Ist der Modus „world“ bereits aktiv, werden alle Zeichnungen entsprechend den neuen Koordinaten neu gezeichnet.

ACHTUNG: In benutzerdefinierten Koordinatensystemen können Winkel verzerrt erscheinen.

>>> 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.delay(delay=None)

Parameter:

delay – positive Ganzzahl

Setze oder gib die Zeichen-delay in Millisekunden zurück. (Dies ist ungefähr das Zeitintervall zwischen zwei aufeinanderfolgenden Aktualisierungen der Zeichenfläche.) Je länger die Zeichen-delay, desto langsamer die Animation.

Optionales Argument:

>>> screen.delay()
10
>>> screen.delay(5)
>>> screen.delay()
5

turtle.tracer(n=None, delay=None)

Parameter:

• n – nichtnegative Ganzzahl

• delay – nichtnegative Ganzzahl

Schalte die Turtle-Animation ein/aus und setze die Verzögerung für Zeichnungsaktualisierungen. Wird n angegeben, wird nur jede n-te reguläre Bildschirmaktualisierung tatsächlich durchgeführt. (Kann verwendet werden, um das Zeichnen komplexer Grafiken zu beschleunigen.) Wird ohne Argumente aufgerufen, wird der aktuell gespeicherte Wert von n zurückgegeben. Das zweite Argument setzt den Verzögerungswert (siehe delay()).

>>> 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)

Setze den Fokus auf TurtleScreen (um Tastatur-Ereignisse zu erfassen). Dummy-Argumente werden bereitgestellt, um listen() an die onclick-Methode übergeben zu können.

turtle.onkey(fun, key)

turtle.onkeyrelease(fun, key)

Parameter:

• fun – eine Funktion ohne Argumente oder None

• key – eine Zeichenkette: Taste (z.B. „a“) oder Tastensymbol (z.B. „space“)

Binde fun an das Loslassen-Ereignis der Taste key. Ist fun None, werden Ereignisbindungen entfernt. Anmerkung: Um Tastatur-Ereignisse registrieren zu können, muss TurtleScreen den Fokus haben. (Siehe Methode listen().)

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

turtle.onkeypress(fun, key=None)

Parameter:

• fun – eine Funktion ohne Argumente oder None

• key – eine Zeichenkette: Taste (z.B. „a“) oder Tastensymbol (z.B. „space“)

Binde fun an das Drücken-Ereignis der Taste key, falls key angegeben ist, oder an jedes Tastendruck-Ereignis, falls kein key angegeben ist. Anmerkung: Um Tastatur-Ereignisse registrieren zu können, muss TurtleScreen den Fokus haben. (Siehe Methode listen().)

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

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

turtle.onscreenclick(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 Mausklick-Ereignisse auf diesem Screen. Ist fun None, werden bestehende Bindungen entfernt.

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 – eine Zahl >= 0

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()

Startet die Ereignisschleife – ruft die mainloop-Funktion von Tkinter auf. Muss die letzte Anweisung in einem Turtle-Grafikprogramm sein. Darf nicht verwendet werden, wenn ein Skript innerhalb von IDLE im -n-Modus (Kein Subprozess) ausgeführt wird – für die interaktive Verwendung von Turtle-Grafik.

>>> screen.mainloop()

Eingabemethoden

turtle.textinput(title, prompt)

Parameter:

• title – Zeichenkette

• prompt – Zeichenkette

Öffne ein Dialogfenster zur Eingabe einer Zeichenkette. Der Parameter title ist der Titel des Dialogfensters, prompt ist ein Text, der meist 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 – Zeichenkette

• prompt – Zeichenkette

• default – Zahl (optional)

• minval – Zahl (optional)

• maxval – Zahl (optional)

Öffne ein Dialogfenster zur Eingabe einer Zahl. title ist der Titel des Dialogfensters, prompt ist ein Text, der meist beschreibt, welche numerische Information einzugeben ist. default: Standardwert, minval: Mindestwert für die Eingabe, maxval: Höchstwert für die Eingabe. Die eingegebene Zahl muss im Bereich minval .. maxval liegen, falls diese angegeben sind. 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 der Zeichenketten „standard“, „logo“ oder „world“

Setze den Turtle-Modus („standard“, „logo“ oder „world“) und führe ein Reset durch. Wird mode nicht angegeben, wird der aktuelle Modus zurückgegeben.

Mode „standard“ is compatible with old turtle. Mode „logo“ is compatible with most Logo turtle graphics. Mode „world“ uses user-defined „world coordinates“. Attention: in this mode angles appear distorted if x/y unit-ratio doesn’t equal 1.

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 – einer der Werte 1.0 oder 255

Gib den colormode zurück oder setze ihn auf 1.0 oder 255. Anschließend müssen die Werte r, g, b von Farb-Tripeln im Bereich 0..*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)

There are three different ways to call this function:

1. name is the name of a gif-file and shape is None: Install the corresponding image shape.

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

   Bemerkung

   Bildformen drehen sich nicht mit, wenn die Turtle gedreht wird, sie zeigen also nicht die Ausrichtung der Turtle an!

2. 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)))
   

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

Füge eine Turtle-Form zur Formenliste des TurtleScreen hinzu. Nur so registrierte Formen können durch den Befehl shape(shapename) verwendet 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

Screen-only methods

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.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, die in der Titelleiste des Turtle-Grafikfensters angezeigt wird

Setze den Titel des Turtle-Fensters auf titlestring.

>>> 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 hinzugefügten Methoden.

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 der Zeichenketten „polygon“, „image“, „compound“

Datenstruktur zur Modellierung von Formen. Das Paar (type_, data) muss dieser Spezifikation folgen:

type_	data
„polygon“	ein Polygon-Tupel, d. h. ein Tupel aus Koordinatenpaaren
„image“	ein Bild (in dieser Form nur intern verwendet!)
„compound“	None (eine zusammengesetzte Form muss mit der Methode addcomponent() erstellt werden)

addcomponent(poly, fill, outline=None)

Parameter:

• poly – ein Polygon, d.h. ein Tupel aus Zahlenpaaren

• fill – eine Farbe, mit der das poly gefüllt wird

• outline – eine Farbe für den Umriss des poly (falls angegeben)

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.

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 guides

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

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 die Hilfe 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.

If you (or your students) want to use turtle with online help in your native language, you have to translate the docstrings and save the resulting file as e.g. turtle_docstringdict_german.py.

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 eingebaute 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 eingebaute 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 eingebauten 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.

• If you set e.g. language = italian the docstringdict turtle_docstringdict_italian.py will be loaded at import time (if present on the import path, e.g. in the same directory as 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.

There can be a turtle.cfg file in the directory where turtle is stored and an additional one in the current working directory. The latter will override the settings of the first one.

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 scripts

The turtledemo package includes a set of demo scripts. These scripts can be run and viewed using the supplied demo viewer as follows:

python -m turtledemo

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

python -m turtledemo.bytedesign

The turtledemo package directory contains:

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

• Multiple scripts demonstrating different features of the turtle module. Examples can be accessed via the Examples menu. They can also be run standalone.

• 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ß!