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

Tutorial

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

Eine Turtle-Umgebung starten

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

from turtle import *

Falls du auf einen Fehler No module named '_tkinter' stößt, musst du das Tk-Interface-Paket auf deinem System installieren.

Einfaches Zeichnen

Schicke die Turtle 100 Schritte vorwärts:

forward(100)

You should see (most likely, in a new window on your display) 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, y=None, *, fill_gap=False)

Parameter:

• x – eine Zahl oder None

• y – eine Zahl oder None

• fill_gap – Ein Boolean

Move turtle to an absolute position. Unlike goto(x, y), a line will not be drawn. The turtle’s orientation does not change. If currently filling, the polygon(s) teleported from will be filled after leaving, and filling will begin again after teleporting. This can be disabled with fill_gap=True, which makes the imaginary line traveled during teleporting act as a fill barrier like in goto(x, y).

>>> 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 – an integer >= 1 (if given)

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

Stamp a copy of the turtle shape onto the canvas at the current turtle position. Return a stamp_id for that stamp, which can be used to delete it by calling clearstamp(stamp_id).

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

turtle.clearstamp(stampid)

Parameter:

stampid – an integer, must be return value of previous stamp() call

Delete stamp with given 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 – an integer (or None)

Delete all or first/last n of turtle’s stamps. If n is None, delete all stamps, if n > 0 delete first n stamps, else if n < 0 delete last n stamps.

>>> 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 in the range 0..10 or a speedstring (see below)

Set the turtle’s speed to an integer value in the range 0..10. If no argument is given, return current speed.

If input is a number greater than 10 or smaller than 0.5, speed is set to 0. Speedstrings are mapped to speedvalues as follows:

• „fastest“: 0

• „fast“: 10

• „normal“: 6

• „slow“: 3

• „slowest“: 1

Speeds from 1 to 10 enforce increasingly faster animation of line drawing and turtle turning.

Attention: speed = 0 means that no animation takes place. forward/back makes turtle jump and likewise left/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()

Pull the pen down – drawing when moving.

turtle.penup()

turtle.pu()

turtle.up()

Pull the pen up – no drawing when moving.

turtle.pensize(width=None)

turtle.width(width=None)

Parameter:

width – a positive number

Set the line thickness to width or return it. If resizemode is set to „auto“ and turtleshape is a polygon, that polygon is drawn with the same line thickness. If no argument is given, the current pensize is returned.

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

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

Parameter:

• pen – a dictionary with some or all of the below listed keys

• pendict – one or more keyword-arguments with the below listed keys as keywords

Return or set the pen’s attributes in a „pen-dictionary“ with the following key/value pairs:

• „shown“: True/False

• „pendown“: True/False

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

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

• „pensize“: positive number

• „speed“: number in range 0..10

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

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

• „outline“: positive number

• „tilt“: number

This dictionary can be used as argument for a subsequent call to pen() to restore the former pen-state. Moreover one or more of these attributes can be provided as keyword-arguments. This can be used to set several pen attributes in one statement.

>>> 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 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/bgcolor call.

pencolor(colorstring)

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

pencolor((r, g, b))

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

pencolor(r, g, b)

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

If turtleshape 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/bgcolor call.

fillcolor(colorstring)

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

fillcolor((r, g, b))

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

fillcolor(r, g, b)

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

If turtleshape 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 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, fillcolor and pencolor, 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 turtleshape is a polygon, outline and interior of that polygon is 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 fillstate (True if filling, False else).

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

turtle.begin_fill()

To be called just before drawing a shape to be filled.

turtle.end_fill()

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

Whether or not overlap regions for self-intersecting polygons or multiple shapes are filled depends on the operating system graphics, type of overlap, and number of overlaps. For example, the Turtle star above may be either all yellow or have some white regions.

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

Mehr Zeichenkontrolle

turtle.reset()

Delete the turtle’s drawings from the screen, re-center the turtle and set variables to the 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. Do not move turtle. State and position of the turtle as well as drawings of other turtles are not affected.

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

Parameter:

• arg – object to be written to the TurtleScreen

• move – True/False

• align – one of the strings „left“, „center“ or right“

• font – a triple (fontname, fontsize, fonttype)

Write text - the string representation of arg - at the current turtle position according to align („left“, „center“ or „right“) and with the given font. If move is true, the pen is moved to the bottom-right corner of the text. By default, move is False.

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

Turtle-Status

Sichtbarkeit

turtle.hideturtle()

turtle.ht()

Make the turtle invisible. It’s a good idea to do this while you’re in the middle of doing some complex drawing, because hiding the turtle speeds up the drawing observably.

>>> turtle.hideturtle()

turtle.showturtle()

turtle.st()

Mache die Turtle sichtbar.

>>> turtle.showturtle()

turtle.isvisible()

Return True if the Turtle is shown, False if it’s hidden.

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

Erscheinungsbild

turtle.shape(name=None)

Parameter:

name – a string which is a valid shapename

Set turtle shape to shape with given name or, if name is not given, return name of current shape. Shape with name must exist in the TurtleScreen’s shape dictionary. Initially there are the following polygon shapes: „arrow“, „turtle“, „circle“, „square“, „triangle“, „classic“. To learn about how to deal with shapes see Screen method register_shape().

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

turtle.resizemode(rmode=None)

Parameter:

rmode – one of the strings „auto“, „user“, „noresize“

Set resizemode to one of the values: „auto“, „user“, „noresize“. If rmode is not given, return current resizemode. Different resizemodes have the following effects:

• „auto“: adapts the appearance of the turtle corresponding to the value of pensize.

• „user“: adapts the appearance of the turtle according to the values of stretchfactor and outlinewidth (outline), which are set by shapesize().

• „noresize“: no adaption of the turtle’s appearance takes place.

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 number

• stretch_len – positive number

• outline – positive number

Return or set the pen’s attributes x/y-stretchfactors and/or outline. Set resizemode to „user“. If and only if resizemode is set to „user“, the turtle will be displayed stretched according to its stretchfactors: stretch_wid is stretchfactor perpendicular to its orientation, stretch_len is stretchfactor in direction of its orientation, outline determines the width of the shape’s outline.

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

Set or return the current shearfactor. Shear the turtleshape according to the given shearfactor shear, which is the tangent of the shear angle. Do not change the turtle’s heading (direction of movement). If shear is not given: return the current shearfactor, i. e. the tangent of the shear angle, by which lines parallel to the heading of the turtle are sheared.

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

turtle.tilt(angle)

Parameter:

angle – eine Zahl

Rotate the turtleshape by angle from its current tilt-angle, but do not change the turtle’s heading (direction of movement).

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

Set or return the current tilt-angle. If angle is given, 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). If angle is not given: return the current tilt-angle, i. e. the angle between the orientation of the turtleshape and the heading of the turtle (its direction of movement).

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

• t12 – a number (optional)

• t21 – a number (optional)

• t12 – a number (optional)

Set or return the current transformation matrix of the turtle shape.

If none of the matrix elements are given, return the transformation matrix as a tuple of 4 elements. Otherwise set the given elements and transform the turtleshape according to the matrix consisting of first row t11, t12 and second row t21, t22. The determinant t11 * t22 - t12 * t21 must not be zero, otherwise an error is raised. Modify stretchfactor, shearfactor and tiltangle according to the given 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()

Return the current shape polygon as tuple of coordinate pairs. This can be used to define a new shape or components of a compound shape.

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

Ereignisse verwenden

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

Parameter:

• fun – eine Funktion mit zwei Argumenten, 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

Bind fun to mouse-click events on this turtle. If fun is None, existing bindings are removed. Example for the anonymous turtle, i.e. 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.begin_poly()

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

turtle.end_poly()

Stop recording the vertices of a polygon. Current turtle position is last vertex of 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 with same position, heading and turtle properties.

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

turtle.getturtle()

turtle.getpen()

Return the Turtle object itself. Only reasonable use: as a function to return the „anonymous turtle“:

>>> 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 undobuffer. If size is an integer, an empty undobuffer of given size is installed. size gives the maximum number of turtle actions that can be undone by the undo() method/function. If size is None, the undobuffer is disabled.

>>> turtle.setundobuffer(42)

turtle.undobufferentries()

Return number of entries in the undobuffer.

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

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

Bemerkung

The Shape class is used internally by the register_shape() method in different ways. The application programmer has to deal with the Shape class only when using compound shapes like shown above!

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 color specification string or as a tuple (see example). May be used as input to another color/pencolor/fillcolor/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 in the range 0..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 in the range 0..colormode.

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

Set background image or return name of current backgroundimage. If picname is a filename, set the corresponding image as background. If picname is "nopic", delete background image, if present. If picname is None, return the filename of the current backgroundimage.

>>> 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 integer, new width of canvas in pixels

• canvheight – positive integer, new height of canvas in pixels

• bg – colorstring or color-tuple, new background color

If no arguments are given, return current (canvaswidth, canvasheight). Else resize the canvas the turtles are drawing on. Do not alter the drawing window. To observe hidden parts of the canvas, use the scrollbars. With this method, one can make visible those parts of a drawing which were outside the canvas before.

>>> 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 – a number, x-coordinate of lower left corner of canvas

• lly – a number, y-coordinate of lower left corner of canvas

• urx – a number, x-coordinate of upper right corner of canvas

• ury – a number, y-coordinate of upper right corner of canvas

Set up user-defined coordinate system and switch to mode „world“ if necessary. This performs a screen.reset(). If mode „world“ is already active, all drawings are redrawn according to the new coordinates.

ATTENTION: in user-defined coordinate systems angles may appear distorted.

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

Set or return 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.

Optional argument:

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

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

Parameter:

• n – nonnegative integer

• delay – nonnegative integer

Turn turtle animation on/off and set delay for update drawings. If n is given, only each n-th regular screen update is really performed. (Can be used to accelerate the drawing of complex graphics.) When called without arguments, returns the currently stored value of n. Second argument sets delay value (see 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)

Set focus on TurtleScreen (in order to collect key-events). Dummy arguments are provided in order to be able to pass listen() to the onclick method.

turtle.onkey(fun, key)

turtle.onkeyrelease(fun, key)

Parameter:

• fun – eine Funktion ohne Argumente oder None

• key – a string: key (e.g. „a“) or key-symbol (e.g. „space“)

Bind fun to key-release event of key. If fun is None, event bindings are removed. Remark: in order to be able to register key-events, TurtleScreen must have the focus. (See method 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 – a string: key (e.g. „a“) or key-symbol (e.g. „space“)

Bind fun to key-press event of key if key is given, or to any key-press-event if no key is given. Remark: in order to be able to register key-events, TurtleScreen must have focus. (See method 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

Bind fun to mouse-click events on this screen. If fun is None, existing bindings are removed.

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

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

Bemerkung

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

turtle.ontimer(fun, t=0)

Parameter:

• fun – eine Funktion ohne Argumente

• t – a number >= 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()

Starts event loop - calling Tkinter’s mainloop function. 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 (No subprocess) - for interactive use of turtle graphics.

>>> screen.mainloop()

Eingabemethoden

turtle.textinput(title, prompt)

Parameter:

• title – string

• prompt – string

Pop up a dialog window for input of a string. Parameter title is the title of the dialog window, prompt is a text mostly describing what information to input. Return the string input. 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 – string

• prompt – string

• default – number (optional)

• minval – number (optional)

• maxval – number (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 – one of the strings „standard“, „logo“ or „world“

Set turtle mode („standard“, „logo“ or „world“) and perform reset. If mode is not given, current mode is returned.

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 – one of the values 1.0 or 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

   Image shapes do not rotate when turning the turtle, so they do not display the heading of the turtle!

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

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

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

Add a turtle shape to TurtleScreen’s shapelist. Only thusly registered shapes can be used by issuing the command shape(shapename).

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

Shut the turtlegraphics 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.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 that is shown in the titlebar of the turtle graphics window

Set title of turtle window to titlestring.

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

Öffentliche Klassen

class turtle.RawTurtle(canvas)

class turtle.RawPen(canvas)

Parameter:

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

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

class turtle.Turtle

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

class turtle.TurtleScreen(cv)

Parameter:

cv – a tkinter.Canvas

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

class turtle.Screen

Subclass of TurtleScreen, with four methods added.

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_ – one of the strings „polygon“, „image“, „compound“

Data structure modeling shapes. The pair (type_, data) must follow this specification:

type_	data
„polygon“	a polygon-tuple, i.e. a tuple of pairs of coordinates
„image“	an image (in this form only used internally!)
„compound“	None (a compound shape has to be constructed using the addcomponent() method)

addcomponent(poly, fill, outline=None)

Parameter:

• poly – a polygon, i.e. a tuple of pairs of numbers

• fill – a color the poly will be filled with

• outline – a color for the poly’s outline (if given)

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

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

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.

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.

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: Setze dies auf True, wenn du regelmäßig mit IDLE und dessen Schalter -n („no subprocess“) arbeitest. Dies verhindert, dass exitonclick() die mainloop aufruft.

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

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

Erklärung

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

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

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

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

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

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

turtledemo — Demo scripts

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

python -m turtledemo

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

python -m turtledemo.bytedesign

The turtledemo package directory contains:

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

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

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

Die Demo-Skripte sind:

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

Viel Spaß!