turtle — Turtle graphics

Quellcode: Lib/turtle.py

Introduction

Turtle graphics is a popular way for introducing programming to kids. It was part of the original Logo programming language developed by Wally Feurzeig, Seymour Papert and Cynthia Solomon in 1967.

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.

By combining together these and similar commands, intricate shapes and pictures can easily be drawn.

The turtle module is an extended reimplementation of the same-named module from the Python standard distribution up to version Python 2.5.

It tries to keep the merits of the old turtle module and to be (nearly) 100% compatible with it. This means in the first place to enable the learning programmer to use all the commands, classes and methods interactively when using the module from within IDLE run with the -n switch.

The turtle module provides turtle graphics primitives, in both object-oriented and procedure-oriented ways. Because it uses tkinter for the underlying graphics, it needs a version of Python installed with Tk support.

The object-oriented interface uses essentially two+two classes:

  1. The TurtleScreen class defines graphics windows as a playground for the drawing turtles. Its constructor needs a tkinter.Canvas or a ScrolledCanvas as argument. It should be used when turtle is used as part of some application.

    The function Screen() returns a singleton object of a TurtleScreen subclass. This function should be used when turtle is used as a standalone tool for doing graphics. As a singleton object, inheriting from its class is not possible.

    All methods of TurtleScreen/Screen also exist as functions, i.e. as part of the procedure-oriented interface.

  2. RawTurtle (alias: RawPen) defines Turtle objects which draw on a TurtleScreen. Its constructor needs a Canvas, ScrolledCanvas or TurtleScreen as argument, so the RawTurtle objects know where to draw.

    Derived from RawTurtle is the subclass Turtle (alias: Pen), which draws on „the“ Screen instance which is automatically created, if not already present.

    All methods of RawTurtle/Turtle also exist as functions, i.e. part of the procedure-oriented interface.

The procedural interface provides functions which are derived from the methods of the classes Screen and Turtle. They have the same names as the corresponding methods. A screen object is automatically created whenever a function derived from a Screen method is called. An (unnamed) turtle object is automatically created whenever any of the functions derived from a Turtle method is called.

To use multiple turtles on a screen one has to use the object-oriented interface.

Bemerkung

In der folgenden Dokumentation wird die Argumentliste für Funktionen angegeben. Methoden haben natürlich das zusätzliche erste Argument self, das hier weggelassen wird.

Overview of available Turtle and Screen methods

Turtle-Methoden

Turtle-Bewegung
Bewegen und zeichnen
forward() | fd()
backward() | bk() | back()
right() | rt()
left() | lt()
goto() | setpos() | setposition()
setx()
sety()
setheading() | seth()
home()
circle()
dot()
stamp()
clearstamp()
clearstamps()
undo()
speed()
Zustand der Turtle abfragen
position() | pos()
towards()
xcor()
ycor()
heading()
distance()
Einstellung und Maß
degrees()
radians()
Stiftsteuerung
Zeichenzustand
pendown() | pd() | down()
penup() | pu() | up()
pensize() | width()
pen()
isdown()
Farbkontrolle
color()
pencolor()
fillcolor()
Füllen
filling()
begin_fill()
end_fill()
Mehr Zeichenkontrolle
reset()
clear()
write()
Turtle-Status
Sichtbarkeit
showturtle() | st()
hideturtle() | ht()
isvisible()
Erscheinungsbild
shape()
resizemode()
shapesize() | turtlesize()
shearfactor()
settiltangle()
tiltangle()
tilt()
shapetransform()
get_shapepoly()
Ereignisse verwenden
onclick()
onrelease()
ondrag()
Spezielle Turtle-Methoden
begin_poly()
end_poly()
get_poly()
clone()
getturtle() | getpen()
getscreen()
setundobuffer()
undobufferentries()

Methoden von TurtleScreen/Screen

Fenstersteuerung
bgcolor()
bgpic()
clearscreen()
resetscreen()
screensize()
setworldcoordinates()
Animationskontrolle
delay()
tracer()
update()
Screen-Events verwenden
listen()
onkey() | onkeyrelease()
onkeypress()
onclick() | onscreenclick()
ontimer()
mainloop() | done()
Einstellungen und spezielle Methoden
mode()
colormode()
getcanvas()
getshapes()
register_shape() | addshape()
turtles()
window_height()
window_width()
Eingabemethoden
textinput()
numinput()
Spezifische Methoden zum Screen
bye()
exitonclick()
setup()
title()

Methoden von RawTurtle/Turtle und entsprechende Funktionen

Turtle-Instanz namens turtle.

Turtle-Bewegung

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

distance – eine Zahl (Ganzzahl oder Gleitkommazahl)

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 (Ganzzahl oder Gleitkommazahl)

Drehe die Turtle um angle Einheiten nach rechts. (Die Einheit ist standardmäßig Grad, kann aber über die Funktionen degrees() und radians() festgelegt werden.) Die Winkelausrichtung 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 (Ganzzahl oder Gleitkommazahl)

Drehe die Turtle um angle Einheiten nach links. (Die Einheit ist standardmäßig Grad, kann aber über die Funktionen degrees() und radians() festgelegt werden.) Die Winkelausrichtung 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

Wenn y None ist, muss x ein Koordinatenpaar oder ein Vec2D sein (z. B. wie von pos() zurückgegeben).

Bewege die Turtle zu einer absoluten Position. Wenn der Stift unten ist, zeichne eine Linie. Die Ausrichtung der Turtle wird dabei nicht verändert.

 >>> tp = turtle.pos()
 >>> tp
 (0.00,0.00)
 >>> turtle.setpos(60,30)
 >>> turtle.pos()
 (60.00,30.00)
 >>> turtle.setpos((20,80))
 >>> turtle.pos()
 (20.00,80.00)
 >>> turtle.setpos(tp)
 >>> turtle.pos()
 (0.00,0.00)
turtle.setx(x)
Parameter

x – eine Zahl (Ganzzahl oder Gleitkommazahl)

Setze die erste Koordinate der Turtle auf x, die zweite 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 (Ganzzahl oder Gleitkommazahl)

Setze die zweite Koordinate der Turtle auf y, die erste 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 (Ganzzahl oder Gleitkommazahl)

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) – und setze ihre Ausrichtung auf die Startausrichtung (die vom 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(size=None, *color)
Parameter

  • size – eine Ganzzahl >= 1 (falls angegeben)

  • color – ein Farbstring oder ein numerisches Farb-Tupel

Draw a circular dot with diameter size, using color. If size is not given, the maximum of pensize+4 and 2*pensize is used.

>>> 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")
>>> turtle.stamp()
11
>>> 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):
...     turtle.stamp(); turtle.fd(30)
13
14
15
16
17
18
19
20
>>> 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()

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 zwischen der Linie von der Position der Turtle zu der durch (x,y), den Vektor oder die andere Turtle angegebenen Position zurück. Dies hängt von der Startausrichtung der Turtle ab, die wiederum vom Modus abhängt – „standard“/“world“ oder „logo“.

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

Gibt 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 die Entfernung von der Turtle zu (x,y), dem angegebenen Vektor oder der angegebenen anderen Turtle in Turtle-Schrittweiten zurück.

>>> 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, d. h. setze die Anzahl der „Grad“ für einen vollen Kreis. Der Standardwert ist 360 Grad.

>>> 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 – 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.penup()
>>> turtle.isdown()
False
>>> turtle.pendown()
>>> turtle.isdown()
True

Farbkontrolle

turtle.pencolor(*args)

Gib die Stiftfarbe zurück oder setze sie.

Vier Eingabeformate sind erlaubt:

pencolor()

Return the current pencolor as color specification string or as a tuple (see example). May be used as input to another color/pencolor/fillcolor call.

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

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

Vier Eingabeformate sind erlaubt:

fillcolor()

Return the current fillcolor as color specification string, possibly in tuple format (see example). May be used as input to another color/pencolor/fillcolor call.

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

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.settiltangle(angle)
Parameter

angle – eine Zahl

Rotate the turtleshape to point in the direction specified by angle, regardless of its current tilt-angle. Do not change the turtle’s heading (direction of movement).

>>> turtle.reset()
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.settiltangle(45)
>>> turtle.fd(50)
>>> turtle.settiltangle(-45)
>>> turtle.fd(50)

Veraltet ab Version 3.1.

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!

Methoden von TurtleScreen/Screen und entsprechende Funktionen

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

Fenstersteuerung

turtle.bgcolor(*args)
Parameter

args – a color string or three numbers in the range 0..colormode or a 3-tuple of such numbers

Set or return background color of the TurtleScreen.

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

z. B. um nach einer fälschlicherweise entkommenen Turtle zu suchen ;-)

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)

Pop up a dialog window for input of a number. title is the title of the dialog window, prompt is a text mostly describing what numerical information to input. default: default value, minval: minimum value for input, maxval: maximum value for input The number input must be in the range minval .. maxval if these are given. If not, a hint is issued and the dialog remains open for correction. Return the number input. If the dialog is canceled, return None.

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

Return the colormode or set it to 1.0 or 255. Subsequently r, g, b values of color triples have to be in the range 0..cmode.

>>> 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 is an arbitrary string and shape is a (compound) Shape object: Install the corresponding compound shape.

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

Methoden spezifisch für Screen, nicht von TurtleScreen geerbt

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 – a tkinter.Canvas, a ScrolledCanvas or a 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

Hilfe und Konfiguration

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

  • 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: Set this to True if you regularly work with IDLE and its -n switch („no subprocess“). This will prevent exitonclick() to enter the mainloop.

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

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 as clock’s hands, 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

Rectangular Turtles as Hanoi discs (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

compound shapes, 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ß!

Changes since Python 2.6

  • The methods Turtle.tracer, Turtle.window_width and Turtle.window_height have been eliminated. Methods with these names and functionality are now available only as methods of Screen. The functions derived from these remain available. (In fact already in Python 2.6 these methods were merely duplications of the corresponding TurtleScreen/Screen methods.)

  • The method Turtle.fill() has been eliminated. The behaviour of begin_fill() and end_fill() have changed slightly: now every filling process must be completed with an end_fill() call.

  • A method Turtle.filling has been added. It returns a boolean value: True if a filling process is under way, False otherwise. This behaviour corresponds to a fill() call without arguments in Python 2.6.

Changes since Python 3.0