`turtle` — Turtle graphics¶

Introduction¶

Turtle graphics is an implementation of the popular geometric drawing tools introduced in Logo, developed by Wally Feurzeig, Seymour Papert and Cynthia Solomon in 1967.

In Python, turtle graphics provides a representation of a physical „turtle“ (a little robot with a pen) that draws on a sheet of paper on the floor.

It’s an effective and well-proven way for learners to encounter programming concepts and interaction with software, as it provides instant, visible feedback. It also provides convenient access to graphical output in general.

Turtle drawing was originally created as an educational tool, to be used by teachers in the classroom. For the programmer who needs to produce some graphical output it can be a way to do that without the overhead of introducing more complex or external libraries into their work.

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

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

The home position is at the center of the turtle’s screen. If you ever need to know them, get the turtle’s x-y co-ordinates with:

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:

while True:
    forward(200)
    left(170)
    if abs(pos()) < 1:
        break

abs(pos()) < 1 is a good way to know when the turtle is back at its home position.

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

How to…¶

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

Get started as quickly as possible¶

One of the joys of turtle graphics is the immediate, visual feedback that’s available from simple commands - it’s an excellent way to introduce children to programming ideas, with a minimum of overhead (not just children, of course).

The turtle module makes this possible by exposing all its basic functionality as functions, available with from turtle import *. The turtle graphics tutorial covers this approach.

It’s worth noting that many of the turtle commands also have even more terse equivalents, such as fd() for forward(). These are especially useful when working with learners for whom typing is not a skill.

You’ll need to have the Tk interface package installed on your system for turtle graphics to work. Be warned that this is not always straightforward, so check this in advance if you’re planning to use turtle graphics with a learner.

Das `turtle`-Modul im eigenen Namensraum verwenden¶

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

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

Turtle-Grafik in einem Skript verwenden¶

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

import turtle as t
from random import random

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

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

t.mainloop()

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

Objektorientierte Turtle-Grafik verwenden¶

Siehe auch

Erklärung der objektorientierten Schnittstelle

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

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

Das obige Beispiel wird dann zu:

from turtle import Turtle
from random import random

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

t.screen.mainloop()

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

Der Turtle-Scree kann angepasst werden, zum Beispiel:

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

Turtle graphics reference¶

Bemerkung

In the following documentation the argument list for functions is given. Methods, of course, have the additional first argument self which is omitted here.

Turtle methods¶

Turtle motion

Bewegen und zeichnen: forward() | fd()

backward() | bk() | back()

right() | rt()

left() | lt()

goto() | setpos() | setposition()

setx()

sety()

setheading() | seth()

home()

circle()

dot()

stamp()

clearstamp()

clearstamps()

undo()

speed()
Zustand der Turtle abfragen: position() | pos()

towards()

xcor()

ycor()

heading()

distance()
Setting and measurement: degrees()

radians()

Stiftsteuerung

Zeichenzustand: pendown() | pd() | down()

penup() | pu() | up()

pensize() | width()

pen()

isdown()
Farbkontrolle: color()

pencolor()

fillcolor()
Füllen: filling()

begin_fill()

end_fill()
Mehr Zeichenkontrolle: reset()

clear()

write()

Turtle-Status

Sichtbarkeit: showturtle() | st()

hideturtle() | ht()

isvisible()
Erscheinungsbild: shape()

resizemode()

shapesize() | turtlesize()

shearfactor()

settiltangle()

tiltangle()

tilt()

shapetransform()

get_shapepoly()

Ereignisse verwenden

onclick()
onrelease()
ondrag()

Spezielle Turtle-Methoden

begin_poly()
end_poly()
get_poly()
clone()
getturtle() | getpen()
getscreen()
setundobuffer()
undobufferentries()

Methods of TurtleScreen/Screen¶

Fenstersteuerung: bgcolor()

bgpic()

clearscreen()

resetscreen()

screensize()

setworldcoordinates()
Animationskontrolle: delay()

tracer()

update()
Screen-Events verwenden: listen()

onkey() | onkeyrelease()

onkeypress()

onclick() | onscreenclick()

ontimer()

mainloop() | done()
Einstellungen und spezielle Methoden: mode()

colormode()

getcanvas()

getshapes()

register_shape() | addshape()

turtles()

window_height()

window_width()
Eingabemethoden: textinput()

numinput()
Methods specific to Screen: bye()

exitonclick()

setup()

title()

Methods of RawTurtle/Turtle and corresponding functions¶

Turtle-Instanz namens turtle.

Turtle motion¶

turtle.forward(distance)¶

turtle.fd(distance)¶

Parameter:: distance – a number (integer or float)

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. Do not change the turtle’s heading.

>>> turtle.position()
(0.00,0.00)
>>> turtle.backward(30)
>>> turtle.position()
(-30.00,0.00)

turtle.right(angle)¶

turtle.rt(angle)¶

Parameter:: angle – a number (integer or float)

Turn turtle right by angle units. (Units are by default degrees, but can be set via the degrees() and radians() functions.) Angle orientation 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 – a number (integer or float)

Turn turtle left by angle units. (Units are by default degrees, but can be set via the degrees() and radians() functions.) Angle orientation 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

If y is None, x must be a pair of coordinates or a Vec2D (e.g. as returned by pos()).

Move turtle to an absolute position. If the pen is down, draw line. Do not change the turtle’s orientation.

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

turtle.setx(x)¶

Parameter:: x – a number (integer or float)

Set the turtle’s first coordinate to x, leave second coordinate unchanged.

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

turtle.sety(y)¶

Parameter:: y – a number (integer or float)

Set the turtle’s second coordinate to y, leave first coordinate 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 – a number (integer or float)

Set the orientation of the turtle 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 turtle to the origin – coordinates (0,0) – and set its heading to its start-orientation (which depends on the 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 – a number (or None)
steps – eine Ganzzahl (oder None)

Draw a circle with 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 direction of the turtle is changed by the amount of 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(size=None, *color)¶

Parameter:

size – eine Ganzzahl >= 1 (falls angegeben)
color – ein Farbstring oder ein numerisches Farb-Tupel

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

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

turtle.stamp()¶

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

>>> turtle.color("blue")
>>> turtle.stamp()
11
>>> turtle.fd(50)

turtle.clearstamp(stampid)¶

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

Lösche den Stempel mit der angegebenen stampid.

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

turtle.clearstamps(n=None)¶

Parameter:: n – eine Ganzzahl (oder None)

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

>>> for i in range(8):
...     turtle.stamp(); turtle.fd(30)
13
14
15
16
17
18
19
20
>>> turtle.clearstamps(2)
>>> turtle.clearstamps(-2)
>>> turtle.clearstamps()

turtle.undo()¶

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

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

turtle.speed(speed=None)¶

Parameter:: speed – eine Ganzzahl im Bereich 0..10 oder ein speedstring (siehe unten)

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

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

„fastest“: 0
„fast“: 10
„normal“: 6
„slow“: 3
„slowest“: 1

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

Achtung: speed = 0 bedeutet, dass keine Animation stattfindet. forward/back lässt die Turtle springen, und ebenso lassen left/right die Turtle sofort drehen.

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

Zustand der Turtle abfragen¶

turtle.position()¶

turtle.pos()¶

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 between the line from turtle position to position specified by (x,y), the vector or the other turtle. This depends on the turtle’s start orientation which depends on the mode - „standard“/“world“ or „logo“.

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

turtle.xcor()¶

Gib die x-Koordinate der Turtle zurück.

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

turtle.ycor()¶

Gib die y-Koordinate der Turtle zurück.

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

turtle.heading()¶

Return the turtle’s current heading (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), the given vector, or the given other turtle, in turtle step units.

>>> 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 angle measurement units, i.e. set number of „degrees“ for a full circle. Default value is 360 degrees.

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

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

turtle.radians()¶

Set the angle measurement units to radians. Equivalent to degrees(2*math.pi).

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

Stiftsteuerung¶

Zeichenzustand¶

turtle.pendown()¶
turtle.pd()¶
turtle.down()¶: Senke den Stift – zeichnet beim Bewegen.

turtle.penup()¶
turtle.pu()¶
turtle.up()¶: Hebe den Stift – zeichnet nicht beim Bewegen.

turtle.pensize(width=None)¶

turtle.width(width=None)¶

Parameter:: width – eine positive Zahl

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

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

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

Parameter:

pen – ein Dictionary mit einigen oder allen der unten aufgeführten Schlüssel
pendict – ein oder mehrere Schlüsselwortargumente mit den unten aufgeführten Schlüsseln als Schlüsselwörter

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

„shown“: True/False
„pendown“: True/False
„pencolor“: Farbstring oder Farb-Tupel
„fillcolor“: Farbstring oder Farb-Tupel
„pensize“: positive Zahl
„speed“: Zahl im Bereich 0..10
„resizemode“: „auto“ or „user“ or „noresize“
„stretchfactor“: (positive Zahl, positive Zahl)
„outline“: positive Zahl
„tilt“: Zahl

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

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

turtle.isdown()¶

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

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

Farbkontrolle¶

turtle.pencolor(*args)¶

Gib die Stiftfarbe zurück oder setze sie.

Vier Eingabeformate sind erlaubt:

pencolor(): Return the current pencolor as color specification string or as a tuple (see example). May be used as input to another color/pencolor/fillcolor call.
pencolor(colorstring): Setze die Stiftfarbe auf colorstring, was ein Tk-Farbangabe-String ist, wie zum Beispiel "red", "yellow" oder "#33cc8c".
pencolor((r, g, b)): Setze die Stiftfarbe auf die durch das Tupel aus r, g und b dargestellte RGB-Farbe. Jeder der Werte r, g und b muss im Bereich 0..colormode liegen, wobei colormode entweder 1.0 oder 255 ist (siehe colormode()).
pencolor(r, g, b): Setze die Stiftfarbe auf die durch r, g und b dargestellte RGB-Farbe. Jeder der Werte r, g und b muss im Bereich 0..colormode liegen.

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

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

turtle.fillcolor(*args)¶

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

Vier Eingabeformate sind erlaubt:

fillcolor(): Return the current fillcolor as color specification string, possibly in tuple format (see example). May be used as input to another color/pencolor/fillcolor call.
fillcolor(colorstring): Setze die Füllfarbe auf colorstring, was ein Tk-Farbangabe-String ist, wie zum Beispiel "red", "yellow" oder "#33cc8c".
fillcolor((r, g, b)): Setze die Füllfarbe auf die durch das Tupel aus r, g und b dargestellte RGB-Farbe. Jeder der Werte r, g und b muss im Bereich 0..colormode liegen, wobei colormode entweder 1.0 oder 255 ist (siehe colormode()).
fillcolor(r, g, b): Setze die Füllfarbe auf die durch r, g und b dargestellte RGB-Farbe. Jeder der Werte r, g und b muss im Bereich 0..colormode liegen.

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

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

turtle.color(*args)¶

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

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

color(): Gib die aktuelle Stiftfarbe und die aktuelle Füllfarbe als Paar von Farbangabe-Strings oder Tupeln zurück, wie sie von pencolor() und fillcolor() zurückgegeben werden.
color(colorstring), color((r,g,b)), color(r,g,b): Eingaben wie bei pencolor(), setzt sowohl fillcolor als auch pencolor auf den angegebenen Wert.
color(colorstring1, colorstring2), color((r1,g1,b1), (r2,g2,b2)): Entspricht pencolor(colorstring1) und fillcolor(colorstring2) und analog, wenn das andere Eingabeformat verwendet wird.

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

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

Siehe auch: Screen-Methode colormode().

Füllen¶

turtle.filling()¶

Gib den Füllstatus zurück (True, wenn gefüllt wird, sonst False).

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

turtle.begin_fill()¶: Muss unmittelbar vor dem Zeichnen einer zu füllenden Form aufgerufen werden.

turtle.end_fill()¶

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

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

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

Mehr Zeichenkontrolle¶

turtle.reset()¶

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

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

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

turtle.resizemode(rmode=None)¶

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

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

„auto“: passt das Erscheinungsbild der Turtle entsprechend dem Wert von pensize an.
„user“: passt das Erscheinungsbild der Turtle gemäß den Werten von stretchfactor und outlinewidth (outline) an, die durch shapesize() gesetzt werden.
„noresize“: es findet keine Anpassung des Erscheinungsbilds der Turtle statt.

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

>>> turtle.resizemode()
'noresize'
>>> turtle.resizemode("auto")
>>> turtle.resizemode()
'auto'

turtle.shapesize(stretch_wid=None, stretch_len=None, outline=None)¶

turtle.turtlesize(stretch_wid=None, stretch_len=None, outline=None)¶

Parameter:

stretch_wid – Positive Zahl
stretch_len – Positive Zahl
outline – Positive Zahl

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

>>> turtle.shapesize()
(1.0, 1.0, 1)
>>> turtle.resizemode("user")
>>> turtle.shapesize(5, 5, 12)
>>> turtle.shapesize()
(5, 5, 12)
>>> turtle.shapesize(outline=8)
>>> turtle.shapesize()
(5, 5, 8)

turtle.shearfactor(shear=None)¶

Parameter:: shear – Zahl (optional)

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

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

turtle.tilt(angle)¶

Parameter:: angle – eine Zahl

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

>>> turtle.reset()
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(30)
>>> turtle.fd(50)
>>> turtle.tilt(30)
>>> turtle.fd(50)

turtle.settiltangle(angle)¶

Parameter:: angle – eine Zahl

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

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

Veraltet ab Version 3.1.

turtle.tiltangle(angle=None)¶

Parameter:: angle – eine Zahl (optional)

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

>>> turtle.reset()
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(45)
>>> turtle.tiltangle()
45.0

turtle.shapetransform(t11=None, t12=None, t21=None, t22=None)¶

Parameter:

t11 – eine Zahl (optional)
t12 – eine Zahl (optional)
t21 – eine Zahl (optional)
t12 – eine Zahl (optional)

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

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

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

turtle.get_shapepoly()¶

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

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

Ereignisse verwenden¶

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

Parameter:

fun – eine Funktion mit zwei Argumenten, die mit den Koordinaten des angeklickten Punkts auf der Zeichenfläche aufgerufen wird
btn – Nummer der Maustaste, standardmäßig 1 (linke Maustaste)
add – True oder False – ist es True, wird eine neue Bindung hinzugefügt, andernfalls ersetzt sie eine vorherige Bindung

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

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

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

turtle.getturtle()¶

turtle.getpen()¶

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

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

turtle.getscreen()¶

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

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

turtle.setundobuffer(size)¶

Parameter:: size – eine Ganzzahl oder None

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

>>> turtle.setundobuffer(42)

turtle.undobufferentries()¶

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

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

Zusammengesetzte Formen¶

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

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

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

Füge nun die Shape zur Formenliste des Screens hinzu und verwende sie:
```
>>> register_shape("myshape", s)
>>> shape("myshape")
```

Bemerkung

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

Methods of TurtleScreen/Screen and corresponding functions¶

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

Fenstersteuerung¶

turtle.bgcolor(*args)¶

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

Set or return background color of the TurtleScreen.

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

turtle.bgpic(picname=None)¶

Parameter:: picname – a string, name of a gif-file or "nopic", or None

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

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

turtle.clear(): Bemerkung

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

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

turtle.reset(): Bemerkung

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

turtle.resetscreen()¶: 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)

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

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)¶: Setze den Fokus auf TurtleScreen (um Tastatur-Ereignisse zu erfassen). Dummy-Argumente werden bereitgestellt, um listen() an die onclick-Methode übergeben zu können.

turtle.onkey(fun, key)¶

turtle.onkeyrelease(fun, key)¶

Parameter:

fun – eine Funktion ohne Argumente oder None
key – eine Zeichenkette: Taste (z.B. „a“) oder Tastensymbol (z.B. „space“)

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

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

turtle.onkeypress(fun, key=None)¶

Parameter:

fun – eine Funktion ohne Argumente oder None
key – eine Zeichenkette: Taste (z.B. „a“) oder Tastensymbol (z.B. „space“)

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

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

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

turtle.onscreenclick(fun, btn=1, add=None)¶

Parameter:

fun – eine Funktion mit zwei Argumenten, die mit den Koordinaten des angeklickten Punkts auf der Zeichenfläche aufgerufen wird
btn – Nummer der Maustaste, standardmäßig 1 (linke Maustaste)
add – True oder False – ist es True, wird eine neue Bindung hinzugefügt, andernfalls ersetzt sie eine vorherige Bindung

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

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

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

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

Einstellungen und spezielle Methoden¶

turtle.mode(mode=None)¶

Parameter:: mode – 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:

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

Methods specific to Screen, not inherited from TurtleScreen¶

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

class turtle.Vec2D(x, y)¶

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

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

a + b Vectoraddition
a - b Vectorsubtraction
a * b Skalarprodukt
k * a und a * k Multiplikation mit Skalar
abs(a) Absolutwert von a
a.rotate(angle) Rotation

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

Help and configuration¶

Wie man die Hilfe verwendet¶

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

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

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

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

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

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


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

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

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

    Aliases: penup | pu | up

    No argument

    >>> turtle.penup()

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

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

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

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

    Example::

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

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

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

    Aliases: penup | pu | up

    No argument

    Example:
    >>> penup()

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

Übersetzung von Docstrings in verschiedene Sprachen¶

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

turtle.write_docstringdict(filename='turtle_docstringdict')¶

Parameter:: filename – eine Zeichenkette, verwendet als Dateiname

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

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

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

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

Wie man Screen und Turtles konfiguriert¶

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

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

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

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

Kurze Erklärung ausgewählter Einträge:

Die ersten vier Zeilen entsprechen den Argumenten der Methode Screen.setup.
Zeile 5 und 6 entsprechen den Argumenten der Methode Screen.screensize.
shape kann eine der integrierten Formen sein, z. B.: arrow, turtle usw. Für weitere Informationen versuche help(shape).
Wenn du keine Füllfarbe verwenden möchtest (d. h. die Turtle transparent machen möchtest), musst du fillcolor = "" schreiben (aber alle nichtleeren Zeichenketten dürfen in der cfg-Datei keine Anführungszeichen haben).
Wenn die Turtle ihren Zustand widerspiegeln soll, musst du resizemode = auto verwenden.
If you set e.g. language = italian the docstringdict turtle_docstringdict_italian.py will be loaded at import time (if present on the import path, e.g. in the same directory as turtle).
Die Einträge exampleturtle und examplescreen legen die Namen dieser Objekte fest, wie sie in den Docstrings vorkommen. Bei der Umwandlung von Methoden-Docstrings in Funktions-Docstrings werden diese Namen aus den Docstrings entfernt.
using_IDLE: 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).

`turtledemo` — Demo scripts¶

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

python -m turtledemo

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

python -m turtledemo.bytedesign

The turtledemo package directory contains:

Einen Demo-Viewer __main__.py, mit dem der Quellcode der Skripte betrachtet und gleichzeitig ausgeführt werden kann.
Multiple scripts demonstrating different features of the turtle module. Examples can be accessed via the Examples menu. They can also be run standalone.
Eine turtle.cfg-Datei, die als Beispiel dient, wie solche Dateien geschrieben und verwendet werden.

Die Demo-Skripte sind:

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

Viel Spaß!

Changes since Python 2.6¶

The methods Turtle.tracer, Turtle.window_width and Turtle.window_height have been eliminated. Methods with these names and functionality are now available only as methods of Screen. The functions derived from these remain available. (In fact already in Python 2.6 these methods were merely duplications of the corresponding TurtleScreen/Screen methods.)
The method Turtle.fill() has been eliminated. The behaviour of begin_fill() and end_fill() have changed slightly: now every filling process must be completed with an end_fill() call.
A method Turtle.filling has been added. It returns a boolean value: True if a filling process is under way, False otherwise. This behaviour corresponds to a fill() call without arguments in Python 2.6.

Changes since Python 3.0¶

The Turtle methods shearfactor(), shapetransform() and get_shapepoly() have been added. Thus the full range of regular linear transforms is now available for transforming turtle shapes. tiltangle() has been enhanced in functionality: it now can be used to get or set the tilt angle. settiltangle() has been deprecated.
The Screen method onkeypress() has been added as a complement to onkey(). As the latter binds actions to the key release event, an alias: onkeyrelease() was also added for it.
The method Screen.mainloop has been added, so there is no longer a need to use the standalone mainloop() function when working with Screen and Turtle objects.
Two input methods have been added: Screen.textinput and Screen.numinput. These pop up input dialogs and return strings and numbers respectively.
Two example scripts tdemo_nim.py and tdemo_round_dance.py have been added to the Lib/turtledemo directory.

turtle — Turtle graphics¶

Introduction¶

Tutorial¶

Eine Turtle-Umgebung starten¶

Einfaches Zeichnen¶

Stiftsteuerung¶

Die Position der Turtle¶

Algorithmische Muster erstellen¶

How to…¶

Get started as quickly as possible¶

Das turtle-Modul im eigenen Namensraum verwenden¶

Turtle-Grafik in einem Skript verwenden¶

Objektorientierte Turtle-Grafik verwenden¶

Turtle graphics reference¶

Turtle methods¶

Methods of TurtleScreen/Screen¶

Methods of RawTurtle/Turtle and corresponding functions¶

Turtle motion¶

Zustand der Turtle abfragen¶

Einstellungen für Messungen¶

Stiftsteuerung¶

Zeichenzustand¶

Farbkontrolle¶

Füllen¶

Mehr Zeichenkontrolle¶

Turtle-Status¶

Sichtbarkeit¶

Erscheinungsbild¶

Ereignisse verwenden¶

Spezielle Turtle-Methoden¶

Zusammengesetzte Formen¶

Methods of TurtleScreen/Screen and corresponding functions¶

Fenstersteuerung¶

Animationskontrolle¶

Screen-Events verwenden¶

Eingabemethoden¶

Einstellungen und spezielle Methoden¶

Methods specific to Screen, not inherited from TurtleScreen¶

Öffentliche Klassen¶

Erklärung¶

Help and configuration¶

Wie man die Hilfe verwendet¶

Übersetzung von Docstrings in verschiedene Sprachen¶

Wie man Screen und Turtles konfiguriert¶

turtledemo — Demo scripts¶

Changes since Python 2.6¶

Changes since Python 3.0¶

`turtle` — Turtle graphics¶

Das `turtle`-Modul im eigenen Namensraum verwenden¶

`turtledemo` — Demo scripts¶