turtle — Turtle-Grafik

Quellcode: Lib/turtle.py

---

Turtle star

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

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

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

Dieses Dokument umfasst vier Hauptabschnitte:

• Tutorial vermittelt die Grundlagen des Zeichnens mit der Turtle.

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

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

• Erklärung liefert Hintergrundinformationen zur objektorientierten Schnittstelle.

Bemerkung

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

Tutorial

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

Eine Turtle-Umgebung starten

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

from turtle import *

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

Nothing appears yet. To open the turtle window, make the turtle visible:

showturtle()

A new window opens, with the turtle in the middle, shown as an arrow heading East.

Einfaches Zeichnen

Schicke die Turtle 100 Schritte vorwärts:

forward(100)

You should see a line drawn by the turtle, heading East. Change the direction of the turtle, so that it turns 120 degrees left (anti-clockwise):

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

Referenz

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

Parameter:

• x – eine Zahl oder None

• y – eine Zahl oder None

• fill_gap – Ein Boolean

Teleport, or instantly move, the turtle to an absolute position. Unlike goto(), no line is drawn. If x or y is not given, that coordinate is kept as it is. The turtle’s heading does not change.

If the turtle is filling a shape, the shape drawn so far is finished and filled before teleporting, and filling starts again at the new position. Pass fill_gap=True to keep filling one shape instead. The teleport then counts as an edge of the shape, as it would with goto().

>>> 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 – a positive integer or None

• color – ein Farbstring oder ein numerisches Farb-Tupel

Draw a circular dot with diameter size, using color. If size is not given, the larger of pensize + 4 and 2 * pensize is used. If color is not given, the current pencolor 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")
>>> 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 – an integer, a string or None

Return or set the turtle’s speed. If speed is not given, return the current speed. Otherwise set the turtle’s speed to an integer from 0 to 10. If speed is a number greater than 10 or smaller than 0.5, the speed is set to 0. You can also use these names instead of numbers:

• „fastest“: 0

• „fast“: 10

• „normal“: 6

• „slow“: 3

• „slowest“: 1

Speeds from 1 to 10 give increasingly faster animation of line drawing and turtle turning. A speed of 0 means that no animation takes place: forward() and back() make the turtle jump, and likewise left() and right() make the turtle turn instantly.

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

Lower the pen. The turtle draws a line when it moves.

turtle.penup()

turtle.pu()

turtle.up()

Lift the pen. The turtle does not draw when it moves.

turtle.pensize(width=None)

turtle.width(width=None)

Parameter:

width – a positive number or None

Return or set the line thickness. If width is not given, return the current pensize. If resizemode is set to „auto“ and the turtle shape is a polygon, that polygon is drawn with the same line thickness.

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

Return True if the pen is down, False if it’s up.

>>> turtle.penup()
>>> turtle.isdown()
False
>>> turtle.pendown()
>>> turtle.isdown()
True

Farbkontrolle

turtle.pencolor()

turtle.pencolor(color, /)

turtle.pencolor(r, g, b, /)

Gib die Stiftfarbe zurück oder setze sie.

Vier Eingabeformate sind erlaubt:

pencolor()

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

pencolor(colorstring)

Set the pencolor to colorstring, which is a Tk color specification string, such as "red", "yellow", or "#33cc8c".

pencolor((r, g, b))

Set the pencolor to the RGB color represented by the tuple of r, g, and b. Each of r, g, and b must be between 0 and colormode, where colormode is either 1.0 or 255 (see colormode()).

pencolor(r, g, b)

Set the pencolor to the RGB color represented by r, g, and b. Each of r, g, and b must be between 0 and colormode.

If the turtle shape is a polygon, the outline of that polygon is drawn with the newly set pencolor.

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

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

fillcolor(colorstring)

Set the fillcolor to colorstring, which is a Tk color specification string, such as "red", "yellow", or "#33cc8c".

fillcolor((r, g, b))

Set the fillcolor to the RGB color represented by the tuple of r, g, and b. Each of r, g, and b must be between 0 and colormode, where colormode is either 1.0 or 255 (see colormode()).

fillcolor(r, g, b)

Set the fillcolor to the RGB color represented by r, g, and b. Each of r, g, and b must be between 0 and colormode.

If the turtle shape is a polygon, the interior of that polygon is drawn with the newly set fillcolor.

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

Return or set the pencolor and fillcolor.

Several input formats are allowed. They use 0 to 3 arguments as follows:

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)

Inputs as in pencolor(). Set both the pencolor and the fillcolor to the given value.

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

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

If the turtle shape is a polygon, the outline and interior of that polygon are drawn with the newly set colors.

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

Return True if the turtle is filling, False otherwise.

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

turtle.fill()

Fülle die Form, die im with turtle.fill():-Block gezeichnet wurde.

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

Die Verwendung von fill() entspricht dem Hinzufügen von begin_fill() vor dem Füllblock und end_fill() nach dem Füllblock:

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

Added in version 3.14.

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

Delete the turtle’s drawings and re-center the turtle. The turtle’s settings are restored to their default values.

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

Delete the turtle’s drawings from the screen. The state and position of the turtle as well as the drawings of other turtles are not affected.

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

Make the turtle invisible. If the pen is down, movement still draws.

turtle.showturtle()

turtle.st()

Mache die Turtle sichtbar.

turtle.isvisible()

Return True if the turtle is visible, False if it’s hidden.

>>> turtle.hideturtle()
>>> turtle.isvisible()
False
>>> turtle.showturtle()
>>> turtle.isvisible()
True

Erscheinungsbild

turtle.shape(name=None)

Parameter:

name – a string or None

Set the turtle shape to the named shape. If name is not given, return the name of the current shape. The shape must exist in the TurtleScreen’s shape dictionary. Initially there are the following shapes: „arrow“, „turtle“, „circle“, „square“, „triangle“ and „classic“. To add shapes, see the Screen method register_shape().

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

turtle.resizemode(rmode=None)

Parameter:

rmode – a string or None

Set the resizemode to „auto“, „user“ or „noresize“. If rmode is not given, return the current resizemode. The different resizemodes have the following effects:

• „auto“: the turtle is resized according to the value of pensize().

• „user“: the turtle is resized according to the stretch factors and outline width, which are set by shapesize().

• „noresize“: the turtle is not resized.

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 – a positive number or None

• stretch_len – a positive number or None

• outline – a positive number or None

Return or set the turtle’s stretch factors and outline width. If no arguments are given, return the current values. Otherwise set resizemode to „user“, so that the turtle is displayed stretched according to its stretch factors:

• stretch_wid: the stretch factor perpendicular to the turtle’s heading

• stretch_len: the stretch factor in the direction of the turtle’s heading

• outline: the width of the shape’s outline

For example, shapesize(2, 1) makes the turtle twice as wide without changing its length. If only stretch_wid is given, stretch_len is set to the same value.

>>> 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 – a function with two arguments or None

• btn – an integer

• add – a boolean or None

Bind fun to mouse-click events on this turtle. fun is called with the coordinates of the clicked point on the canvas. If fun is None, existing bindings are removed. btn is the number of the mouse button and defaults to 1, the left mouse button. If add is True, a new binding is added, otherwise it replaces a former binding. Example for the anonymous turtle, that is, the procedural way:

>>> def turn(x, y):
...     left(180)
...
>>> onclick(turn)  # Now clicking into the turtle will turn it.
>>> onclick(None)  # event-binding will be removed

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

Parameter:

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

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

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

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

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

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

Parameter:

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

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

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

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

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

>>> turtle.ondrag(turtle.goto)

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

Spezielle Turtle-Methoden

turtle.poly()

Zeichne die Eckpunkte eines Polygons auf, das im with turtle.poly():-Block gezeichnet wird. Der erste und letzte Eckpunkt werden verbunden.

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

Added in version 3.14.

turtle.begin_poly()

Start recording the vertices of a polygon. The current turtle position is the first vertex of the polygon.

turtle.end_poly()

Stop recording the vertices of a polygon. The current turtle position is the last vertex of the polygon. This will be connected with the first vertex.

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

Create and return a clone of the turtle. The clone has the same position, heading and turtle properties.

>>> leonel = Turtle()
>>> marco = leonel.clone()

turtle.getturtle()

turtle.getpen()

Return the Turtle object itself.

Call getturtle() to get the turtle used by functions such as forward() and left():

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

Set or disable the undo buffer. If size is an integer, an empty undo buffer of the given size is installed. size is the maximum number of turtle actions that can be undone by undo(). If size is None, the undo buffer is disabled.

>>> turtle.setundobuffer(42)

turtle.undobufferentries()

Return the number of entries in the undo buffer.

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

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

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

bgcolor(colorstring)

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

bgcolor((r, g, b))

Set the background color to the RGB color represented by the tuple of r, g, and b. Each of r, g, and b must be between 0 and colormode, where colormode is either 1.0 or 255 (see colormode()).

bgcolor(r, g, b)

Set the background color to the RGB color represented by r, g, and b. Each of r, g, and b must be between 0 and colormode.

>>> screen.bgcolor("orange")
>>> screen.bgcolor()
'orange'
>>> screen.bgcolor("#800080")
>>> screen.bgcolor()
(128.0, 0.0, 128.0)

turtle.bgpic(picname=None)

Parameter:

picname – eine Zeichenkette, Name einer Bilddatei (PNG, GIF, PGM und PPM) oder "nopic", oder 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()

Reset all turtles on the screen to their initial state.

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

• lly – eine Zahl

• urx – eine Zahl

• ury – eine Zahl

Set up a user-defined coordinate system. llx and lly are the x and y coordinates of the lower left corner of the canvas. urx and ury are the x and y coordinates of the upper right corner. Switch to mode „world“ if necessary, which performs a reset. If mode „world“ is already active, all drawings are redrawn according to the new coordinates. In user-defined coordinate systems, angles may appear distorted, see mode().

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

Animationskontrolle

turtle.no_animation()

Temporarily turn off turtle animation. The code inside the with block is not animated. Once the block is exited, the drawing appears. This is useful for drawing complex shapes where even the fastest speed setting is too slow.

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

Added in version 3.14.

turtle.delay(delay=None)

Parameter:

delay – a nonnegative integer or None

Return or set the drawing delay in milliseconds. This is approximately the time interval between two consecutive canvas updates. The longer the drawing delay, the slower the animation.

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

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

Parameter:

• n – a nonnegative integer or None

• delay – a nonnegative integer or None

Turn turtle animation on or off and set the drawing delay. If n is given, only every n-th regular screen update is performed, which can be used to speed up the drawing of complex graphics. If n is 0, animation is turned off and the screen is only updated by calling update(). If delay is given, it sets the drawing delay, see delay(). When called without arguments, return the current value of n.

>>> 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 – a function with two arguments or None

• btn – an integer

• add – a boolean or None

Bind fun to mouse-click events on this screen. fun is called with the coordinates of the clicked point on the canvas. If fun is None, existing bindings are removed. btn is the number of the mouse button and defaults to 1, the left mouse button. If add is True, a new binding is added, otherwise it replaces a former binding.

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

Start the event loop by calling Tkinter’s mainloop() method. Must be the last statement in a turtle graphics program. Must not be used if a script is run from within IDLE in -n mode (see Running without a subprocess).

Eingabemethoden

turtle.textinput(title, prompt)

Parameter:

• title – a string

• prompt – a string

Pop up a dialog window for input of a string. title is the title of the dialog window and prompt is a text describing what information to input. Return the string entered. If the dialog is canceled, return None.

>>> screen.textinput("NIM", "Name of first player:")

turtle.numinput(title, prompt, default=None, minval=None, maxval=None)

Parameter:

• title – a string

• prompt – a string

• default – eine Zahl oder None

• minval – eine Zahl oder None

• maxval – eine Zahl oder None

Pop up a dialog window for input of a number. title is the title of the dialog window and prompt is a text describing what numerical information to input. default is the default value, minval and maxval are the minimum and maximum values for input. If these are given, the number entered must be between minval and maxval. If not, a hint is issued and the dialog remains open for correction. Return the number entered. 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 – a string or None

Set the turtle mode and perform a reset. mode is one of the strings „standard“, „logo“ or „world“. If mode is not given, return the current mode.

Mode „standard“ is compatible with the old turtle module. Mode „logo“ is compatible with most Logo turtle graphics. Mode „world“ uses user-defined world coordinates, see setworldcoordinates(). In this mode, angles appear distorted if the x and y units are not of equal length.

Modus	Anfängliche Ausrichtung der Turtle	positive Winkel
„standard“	nach rechts (Osten)	gegen den Uhrzeigersinn
„logo“	nach oben (Norden)	im Uhrzeigersinn

>>> mode("logo")  # resets turtle heading to north
>>> mode()
'logo'

turtle.colormode(cmode=None)

Parameter:

cmode – eine Zahl oder None

Return the colormode or set it to 1.0 or 255. After setting it, the r, g and b values of color triples have to be between 0 and 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)

Parameter:

• name – a string

• shape – a string, a tuple of pairs of numbers, a Shape object or None

Add a turtle shape to the TurtleScreen’s shape list. It can be called in four different ways:

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

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

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

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

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

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

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

Image shapes do not rotate when turning the turtle, so they do not display the heading of the turtle. To use a registered shape, call shape() with its name.

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

turtle.turtles()

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

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

turtle.window_height()

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

>>> screen.window_height()
480

turtle.window_width()

Gib die Weite des Turtle-Fensters zurück.

>>> screen.window_width()
640

Screen-only methods

turtle.bye()

Close the turtle graphics window.

turtle.exitonclick()

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

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

turtle.save(filename, overwrite=False)

Speichere die aktuelle Turtle-Zeichnung (und Turtles) als PostScript-Datei.

Parameter:

• filename – der Pfad der gespeicherten PostScript-Datei

• overwrite – Ist es False und es existiert bereits eine Datei mit dem angegebenen Dateinamen, löst die Funktion einen FileExistsError aus. Ist es True, wird die Datei überschrieben.

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

Added in version 3.14.

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

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

Parameter:

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

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

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

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

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

turtle.title(titlestring)

Parameter:

titlestring – a string

Set the title of the turtle window to titlestring. The title is shown in the title bar of the turtle graphics window.

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

Subclass of TurtleScreen, with four methods added. Calling Screen() returns the single screen object. If it does not exist yet, it is created. Otherwise the existing one is returned.

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_ – a string

• data – depends on type_

Data structure modeling shapes. type_ is one of the strings „polygon“, „image“ or „compound“. What data must be depends on type_: for „polygon“ a tuple of pairs of coordinates, for „image“ an image (only used internally), and for „compound“ None, as a compound shape is built up using the addcomponent() method.

addcomponent(poly, fill, outline=None)

Parameter:

• poly – a tuple of pairs of numbers

• fill – a color

• outline – a color or None

Add a component to a shape of type „compound“. poly is a polygon, a tuple of pairs of numbers. fill is the color the polygon is filled with and outline is the color of its outline. If outline is not given, fill is used for it as well.

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 How to use compound shapes.

class turtle.Vec2D(x, y)

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

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

• a + b Vectoraddition

• a - b Vectorsubtraction

• a * b Skalarprodukt

• k * a und a * k Multiplikation mit Skalar

• abs(a) Absolutwert von a

• a.rotate(angle) Rotation

Erklärungen

Das Modul turtle definiert die folgende Ausnahme:

exception turtle.TurtleGraphicsError

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

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

How-to-Anleitungen

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

How to automatically begin and end filling

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

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

forward(200)

Der obige Code ist äquivalent zu:

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

forward(200)

How to use compound shapes

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

1. Create an empty Shape object of type „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")
   

How to use the turtle module namespace

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

How to use turtle graphics in a script

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.

How to use object-oriented turtle graphics

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

How to use help()

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

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

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

  >>> help(Screen.bgcolor)
  Help on method bgcolor in module turtle:
  
  bgcolor(self, *args) unbound turtle.Screen method
      Set or return backgroundcolor of the TurtleScreen.
  
      Arguments (if given): a color string or three numbers
      in the range 0..colormode or a 3-tuple of such numbers.
  
  
      >>> screen.bgcolor("orange")
      >>> screen.bgcolor()
      "orange"
      >>> screen.bgcolor(0.5,0,0.5)
      >>> screen.bgcolor()
      "#800080"
  
  >>> help(Turtle.penup)
  Help on method penup in module turtle:
  
  penup(self) unbound turtle.Turtle method
      Pull the pen up -- no drawing when moving.
  
      Aliases: penup | pu | up
  
      No argument
  
      >>> turtle.penup()
  

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

  >>> help(bgcolor)
  Help on function bgcolor in module turtle:
  
  bgcolor(*args)
      Set or return backgroundcolor of the TurtleScreen.
  
      Arguments (if given): a color string or three numbers
      in the range 0..colormode or a 3-tuple of such numbers.
  
      Example::
  
        >>> bgcolor("orange")
        >>> bgcolor()
        "orange"
        >>> bgcolor(0.5,0,0.5)
        >>> bgcolor()
        "#800080"
  
  >>> help(penup)
  Help on function penup in module turtle:
  
  penup()
      Pull the pen up -- no drawing when moving.
  
      Aliases: penup | pu | up
  
      No argument
  
      Example:
      >>> penup()
  

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

Übersetzung von Docstrings in verschiedene Sprachen

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

turtle.write_docstringdict(filename='turtle_docstringdict')

Parameter:

filename – eine Zeichenkette, verwendet als Dateiname

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

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

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

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

Wie man Screen und Turtles konfiguriert

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

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

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

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

Kurze Erklärung ausgewählter Einträge:

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

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

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

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

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

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

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

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

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

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

Erklärung

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

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

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

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

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

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

turtledemo — Demo-Skripte

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

python -m turtledemo

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

python -m turtledemo.bytedesign

Das Paketverzeichnis turtledemo enthält:

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

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

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

Die Demo-Skripte sind:

Name	Beschreibung	Feature
bytedesign	komplexes klassisches Turtle-Grafik-Muster	tracer(), delay(), update()
chaos	stellt die Verhulst-Dynamik grafisch dar und zeigt, dass Computerberechnungen manchmal Ergebnisse liefern können, die dem gesunden Menschenverstand widersprechen	Welt Koordinaten
clock	analoge Uhr, die die Zeit deines Computers anzeigt	Turtles als Uhrzeiger, ontimer()
colormixer	Experiment mit r, g, b	ondrag()
forest	3 Breitensuche-Bäume	Zufallsgenerierung
fractalcurves	Hilbert & Koch Kurven	Rekursion
lindenmayer	Ethnomathematik (indische Kolams)	L-System
minimal_hanoi	Türme von Hannoi	Rechteckige Turtles als Hanoi-Scheiben (shape(), shapesize())
nim	spiele das klassische Nim-Spiel mit drei Stapeln aus Stäbchen gegen den Computer.	Turtles als Nim-Stäbchen, ereignisgesteuert (Maus, Tastatur)
paint	super minimalistisches Zeichenprogramm	onclick()
peace	Elementar	Turtle: Erscheinungsbild und Animation
penrose	aperiodische Kachelung mit Drachen und Pfeilen	stamp()
planet_and_moon	Simulation eines Gravitationssystems	zusammengesetzte Formen, Vec2D
rosette	ein Muster aus dem Wikipedia-Artikel über Turtle-Grafik	clone(), undo()
round_dance	tanzende Turtles, die sich paarweise in entgegengesetzter Richtung drehen	zusammengesetzte Formen, clone() shapesize(), tilt(), get_shapepoly(), update()
sorting_animate	visuelle Demonstration verschiedener Sortiermethoden	einfache Ausrichtung, Zufallsgenerierung
tree	ein (grafischer) Breitensuche-Baum (unter Verwendung von Generatoren)	clone()
two_canvases	einfaches Design	Turtles auf zwei Canvas
yinyang	ein weiteres elementares Beispiel	circle()

Viel Spaß!