turtle — Turtle-Grafik

Quellcode: Lib/turtle.py

Einleitung

Turtle-Grafik ist eine Implementierung der beliebten geometrischen Zeichenwerkzeuge, die in Logo eingeführt wurden, entwickelt von Wally Feurzeig, Seymour Papert und Cynthia Solomon im Jahr 1967.

Erste Schritte

Stellen Sie sich eine Roboter-Schildkröte vor, die bei (0, 0) in der x-y-Ebene startet. Nach einem import turtle geben Sie ihr den Befehl turtle.forward(15), und sie bewegt sich (auf dem Bildschirm!) 15 Pixel in die Richtung, in die sie gerade blickt, und zeichnet dabei eine Linie. Geben Sie ihr den Befehl turtle.right(25), und sie dreht sich an Ort und Stelle um 25 Grad im Uhrzeigersinn.

In Python bietet die Turtle-Grafik eine Darstellung einer physischen „Schildkröte“ (ein kleiner Roboter mit einem Stift), der auf einem Blatt Papier auf dem Boden zeichnet.

Es ist eine effektive und bewährte Methode für Lernende, Programmierkonzepte und die Interaktion mit Software kennenzulernen, da sie sofortiges, sichtbares Feedback liefert. Sie bietet auch einen bequemen Zugriff auf grafische Ausgaben im Allgemeinen.

Die Schildkröten-Grafik wurde ursprünglich als Bildungswerkzeug für Lehrer im Klassenzimmer geschaffen. Für Programmierer, die grafische Ausgaben erstellen müssen, kann sie eine Möglichkeit sein, dies zu tun, ohne den Aufwand, komplexere oder externe Bibliotheken in ihre Arbeit einzubinden.

Tutorial

Neue Benutzer sollten hier beginnen. In diesem Tutorial werden wir einige Grundlagen der Schildkröten-Grafik untersuchen.

Starten einer Schildkröten-Umgebung

Importieren Sie in einer Python-Shell alle Objekte aus dem turtle Modul.

from turtle import *

Wenn Sie auf einen Fehler No module named '_tkinter' stoßen, müssen Sie das Tk Interface-Paket auf Ihrem System installieren.

Grundlegendes Zeichnen

Bewegen Sie die Schildkröte 100 Schritte vorwärts.

forward(100)

Sie sollten (höchstwahrscheinlich in einem neuen Fenster auf Ihrem Bildschirm) eine Linie sehen, die von der Schildkröte gezeichnet wurde und nach Osten zeigt. Ändern Sie die Richtung der Schildkröte, sodass sie sich um 120 Grad nach links (gegen den Uhrzeigersinn) dreht.

left(120)

Fahren wir fort und zeichnen ein Dreieck.

forward(100)
left(120)
forward(100)

Beachten Sie, wie die Schildkröte, dargestellt durch einen Pfeil, in verschiedene Richtungen zeigt, während Sie sie steuern.

Experimentieren Sie mit diesen Befehlen und auch mit backward() und right().

Stiftsteuerung

Versuchen Sie, die Farbe zu ändern – zum Beispiel color('blue') – und die Breite der Linie – zum Beispiel width(3) – und dann erneut zu zeichnen.

Sie können die Schildkröte auch bewegen, ohne zu zeichnen, indem Sie den Stift anheben: up() vor der Bewegung. Um wieder zu zeichnen, verwenden Sie down().

Die Position der Schildkröte

Bringen Sie Ihre Schildkröte zu ihrem Ausgangspunkt zurück (nützlich, wenn sie vom Bildschirm verschwunden ist).

home()

Die Heimatposition ist in der Mitte des Schildkrötenbildschirms. Wenn Sie sie jemals wissen müssen, erhalten Sie die x-y-Koordinaten der Schildkröte mit

pos()

Heimat ist bei (0, 0).

Und nach einer Weile wird es wahrscheinlich hilfreich sein, das Fenster zu löschen, damit wir von neuem beginnen können.

clearscreen()

Algorithmus-basierte Muster erstellen

Mit 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 Vorstellungskraft begrenzt sind!

Lassen Sie uns die Sternform oben auf dieser Seite zeichnen. Wir wollen rote Linien, gefüllt mit Gelb.

color('red')
fillcolor('yellow')

So 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 ist ein guter Weg, um zu wissen, wann sich die Schildkröte wieder an ihrem Heimatpunkt befindet.

Schließlich vervollständigen Sie das Füllen.

end_fill()

(Beachten Sie, dass das Füllen tatsächlich erst stattfindet, wenn Sie den Befehl end_fill() geben.)

Wie geht das…

Dieser Abschnitt behandelt einige typische Anwendungsfälle und Ansätze für die Schildkröten-Grafik.

So schnell wie möglich loslegen

Einer der Freuden der Schildkröten-Grafik ist das sofortige, visuelle Feedback, das durch einfache Befehle verfügbar ist – es ist eine hervorragende Möglichkeit, Kindern Programmierideen mit minimalem Aufwand näherzubringen (nicht nur Kindern, natürlich).

Das Turtle-Modul macht dies möglich, indem es seine gesamte grundlegende Funktionalität als Funktionen verfügbar macht, die mit from turtle import * aufgerufen werden können. Das Turtle-Grafik-Tutorial behandelt diesen Ansatz.

Es ist erwähnenswert, dass viele der Schildkrötenbefehle auch noch kürzere Entsprechungen haben, wie z. B. fd() für forward(). Diese sind besonders nützlich bei der Arbeit mit Lernenden, für die Tippen noch keine Fähigkeit ist.

Sie müssen das Tk Interface-Paket auf Ihrem System installiert haben, damit die Schildkröten-Grafik funktioniert. Seien Sie gewarnt, dass dies nicht immer einfach ist, prüfen Sie dies also im Voraus, wenn Sie planen, Schildkröten-Grafik mit einem Lernenden zu verwenden.

Automatisches Starten und Beenden des Füllens

Ab Python 3.14 können Sie den fill() Context Manager anstelle von begin_fill() und end_fill() verwenden, um das Füllen automatisch zu starten und zu beenden. Hier ist ein Beispiel:

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

forward(200)

Der obige Code ist äquivalent zu:

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

forward(200)

Verwenden des turtle Modul-Namensraums

Die Verwendung von from turtle import * ist praktisch – aber Vorsicht, dies importiert eine ziemlich große Sammlung von Objekten, und wenn Sie etwas anderes als Schildkröten-Grafik tun, riskieren Sie Namenskonflikte (dies wird umso problematischer, wenn Sie Schildkröten-Grafik in einem Skript verwenden, in dem andere Module importiert werden könnten).

Die Lösung ist die Verwendung von import turtle – fd() wird zu turtle.fd(), width() wird zu turtle.width() und so weiter. (Wenn das wiederholte Tippen von „turtle“ mühsam wird, verwenden Sie stattdessen z. B. import turtle as t.)

Schildkröten-Grafik in einem Skript verwenden

Es wird empfohlen, den turtle Modul-Namensraum wie 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 erforderlich – sobald das Skript endet, schließt Python auch das Fenster der Schildkröte. Fügen Sie hinzu:

t.mainloop()

am Ende des Skripts. Das Skript wartet nun auf die Bestätigung und wird nicht beendet, bis es abgebrochen wird, z. B. durch Schließen des Schildkröten-Grafikfensters.

Objektorientierte Schildkröten-Grafik verwenden

Siehe auch

Erklärung der objektorientierten Schnittstelle

Außer für sehr grundlegende Einführungsvorhaben oder zum schnellen Ausprobieren ist es üblicher und wesentlich leistungsfähiger, den objektorientierten Ansatz für die Schildkröten-Grafik zu verwenden. So können beispielsweise mehrere Schildkröten gleichzeitig auf dem Bildschirm angezeigt werden.

Bei diesem Ansatz sind die verschiedenen Schildkrötenbefehle Methoden von Objekten (meist von Turtle-Objekten). Sie *können* den objektorientierten Ansatz in der Shell verwenden, aber er wäre typischer 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()

Beachten Sie die letzte Zeile. t.screen ist eine Instanz von Screen, auf der eine Turtle-Instanz existiert; sie wird automatisch zusammen mit der Schildkröte erstellt.

Der Schildkrötenbildschirm kann angepasst werden, zum Beispiel:

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

Schildkröten-Grafik Referenz

Hinweis

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

Turtle-Methoden

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

Methoden von TurtleScreen/Screen

Fenstersteuerung
bgcolor()
bgpic()
clearscreen()
resetscreen()
screensize()
setworldcoordinates()
Animationssteuerung
no_animation()
delay()
tracer()
update()
Bildschirmaereignisse 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()
Spezielle Methoden für Screen
bye()
exitonclick()
save()
setup()
title()

Methoden von RawTurtle/Turtle und entsprechende Funktionen

Die meisten Beispiele in diesem Abschnitt beziehen sich auf eine Turtle-Instanz namens turtle.

Turtle-Bewegung

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

distance – eine Zahl (Ganzzahl oder Gleitkommazahl)

Bewegen Sie die Schildkröte um die angegebene *distance* vorwärts, in der Richtung, in die die Schildkröte 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

Bewegen Sie die Schildkröte um *distance* rückwärts, entgegen der Richtung, in die die Schildkröte blickt. Ändern Sie nicht die Blickrichtung der Schildkröte.

>>> turtle.position()
(0.00,0.00)
>>> turtle.backward(30)
>>> turtle.position()
(-30.00,0.00)
turtle.right(angle)
turtle.rt(angle)
Parameter:

angle – eine Zahl (Ganzzahl oder Gleitkommazahl)

Drehen Sie die Schildkröte um *angle* Einheiten nach rechts. (Einheiten sind standardmäßig Grad, können aber über die Funktionen degrees() und radians() gesetzt werden.) Die Winkelorientierung hängt vom Schildkrötenmodus ab, siehe mode().

>>> turtle.heading()
22.0
>>> turtle.right(45)
>>> turtle.heading()
337.0
turtle.left(angle)
turtle.lt(angle)
Parameter:

angle – eine Zahl (Ganzzahl oder Gleitkommazahl)

Drehen Sie die Schildkröte um *angle* Einheiten nach links. (Einheiten sind standardmäßig Grad, können aber über die Funktionen degrees() und radians() gesetzt werden.) Die Winkelorientierung hängt vom Schildkrötenmodus ab, siehe mode().

>>> turtle.heading()
22.0
>>> turtle.left(45)
>>> turtle.heading()
67.0
turtle.goto(x, y=None)
turtle.setpos(x, y=None)
turtle.setposition(x, y=None)
Parameter:

  • x – eine Zahl oder ein Paar/Vektor von Zahlen

  • y – eine Zahl oder None

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

Bewegen Sie die Schildkröte zu einer absoluten Position. Wenn der Stift unten ist, zeichnen Sie eine Linie. Ändern Sie nicht die Ausrichtung der Schildkröte.

>>> 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.teleport(x, y=None, *, fill_gap=False)
Parameter:

  • x – eine Zahl oder None

  • y – eine Zahl oder None

  • fill_gap – ein Boolescher Wert

Bewegen Sie die Schildkröte zu einer absoluten Position. Im Gegensatz zu goto(x, y) wird keine Linie gezeichnet. Die Ausrichtung der Schildkröte ändert sich nicht. Wenn gerade gefüllt wird, werden die Polygon(e), von denen teleportiert wurde, nach dem Verlassen gefüllt, und das Füllen beginnt nach dem Teleportieren erneut. Dies kann mit fill_gap=True deaktiviert werden, was die imaginäre Linie, die während des Teleportierens durchlaufen wird, als Füllbarriere wie bei goto(x, y) wirken lässt.

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

Hinzugefügt in Version 3.12.

turtle.setx(x)
Parameter:

x – eine Zahl (Ganzzahl oder Gleitkommazahl)

Setzen Sie die erste Koordinate der Schildkröte auf *x*, lassen Sie die zweite Koordinate unverändert.

>>> turtle.position()
(0.00,240.00)
>>> turtle.setx(10)
>>> turtle.position()
(10.00,240.00)
turtle.sety(y)
Parameter:

y – eine Zahl (Ganzzahl oder Gleitkommazahl)

Setzen Sie die zweite Koordinate der Schildkröte auf *y*, lassen Sie die erste Koordinate unverändert.

>>> turtle.position()
(0.00,40.00)
>>> turtle.sety(-10)
>>> turtle.position()
(0.00,-10.00)
turtle.setheading(to_angle)
turtle.seth(to_angle)
Parameter:

to_angle – eine Zahl (Ganzzahl oder Gleitkommazahl)

Setzen Sie die Ausrichtung der Schildkröte auf *to_angle*. Hier sind einige gängige Richtungen in Grad:

Standardmodus

Logo-Modus

0 - Ost

0 - Nord

90 - Nord

90 - Ost

180 - West

180 - Süd

270 - Süd

270 - West

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

Bewegen Sie die Schildkröte zum Ursprung – Koordinaten (0,0) – und setzen Sie ihre Ausrichtung auf die Startorientierung (die vom Modus abhängt, siehe mode()).

>>> turtle.heading()
90.0
>>> turtle.position()
(0.00,-10.00)
>>> turtle.home()
>>> turtle.position()
(0.00,0.00)
>>> turtle.heading()
0.0
turtle.circle(radius, extent=None, steps=None)
Parameter:

  • radius – eine Zahl

  • extent – eine Zahl (oder None)

  • steps – eine Ganzzahl (oder None)

Zeichnen Sie einen Kreis mit dem angegebenen *radius*. Das Zentrum liegt *radius* Einheiten links von der Schildkröte; *extent* – ein Winkel – bestimmt, welcher Teil des Kreises gezeichnet wird. Wenn *extent* nicht angegeben ist, wird der gesamte Kreis gezeichnet. Wenn *extent* kein voller Kreis ist, ist ein Endpunkt des Bogens die aktuelle Stiftposition. Zeichnen Sie den Bogen gegen den Uhrzeigersinn, wenn *radius* positiv ist, andernfalls im Uhrzeigersinn. Schließlich wird die Richtung der Schildkröte um den Betrag von *extent* geändert.

Da der Kreis durch ein einbeschriebenes regelmäßiges Polygon angenähert wird, bestimmt *steps* die Anzahl der zu verwendenden Schritte. Wenn nicht angegeben, wird er automatisch berechnet. Kann zum Zeichnen von regelmäßigen Polygonen verwendet werden.

>>> turtle.home()
>>> turtle.position()
(0.00,0.00)
>>> turtle.heading()
0.0
>>> turtle.circle(50)
>>> turtle.position()
(-0.00,0.00)
>>> turtle.heading()
0.0
>>> turtle.circle(120, 180)  # draw a semicircle
>>> turtle.position()
(0.00,240.00)
>>> turtle.heading()
180.0
turtle.dot()
turtle.dot(size)
turtle.dot(color, /)
turtle.dot(size, color, /)
turtle.dot(size, r, g, b, /)
Parameter:

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

  • color – ein Farbstring oder ein numerisches Farb-Tupel

Zeichnet einen kreisförmigen Punkt mit dem Durchmesser size und der Farbe color. Wenn size nicht angegeben ist, wird das Maximum von pensize+4 und 2*pensize verwendet.

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

Stempelt eine Kopie der Schildkrötenform auf die Zeichenfläche an der aktuellen Schildkrötenposition. Gibt eine stamp_id für diesen Stempel zurück, die verwendet werden kann, um ihn durch Aufrufen von clearstamp(stamp_id) zu löschen.

>>> turtle.color("blue")
>>> stamp_id = turtle.stamp()
>>> turtle.fd(50)
turtle.clearstamp(stampid)
Parameter:

stampid – eine Ganzzahl, muss der Rückgabewert eines früheren stamp()-Aufrufs sein.

Löscht 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öscht alle oder die ersten/letzten n Stempel der Schildkröte. Wenn n None ist, werden alle Stempel gelöscht. Wenn n > 0, werden die ersten n Stempel gelöscht. Andernfalls, wenn n < 0, werden die letzten n Stempel gelöscht.

>>> for i in range(8):
...     unused_stamp_id = turtle.stamp()
...     turtle.fd(30)
>>> turtle.clearstamps(2)
>>> turtle.clearstamps(-2)
>>> turtle.clearstamps()
turtle.undo()

Macht die letzte(n) Schildkrötenaktion(en) rückgängig (wiederholt). 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 Geschwindigkeitsstring (siehe unten)

Setzt die Geschwindigkeit der Schildkröte auf einen Ganzzahlwert im Bereich 0..10. Wenn kein Argument angegeben ist, wird die aktuelle Geschwindigkeit zurückgegeben.

Wenn die Eingabe eine Zahl größer als 10 oder kleiner als 0,5 ist, wird die Geschwindigkeit auf 0 gesetzt. Geschwindigkeitsstrings werden wie folgt zu Geschwindigkeitswerten zugeordnet:

  • “fastest”: 0

  • “fast”: 10

  • “normal”: 6

  • “slow”: 3

  • “slowest”: 1

Geschwindigkeiten von 1 bis 10 erzwingen zunehmend schnellere Animationen beim Zeichnen von Linien und Drehen der Schildkröte.

Achtung: speed = 0 bedeutet, dass keine Animation stattfindet. forward/back lässt die Schildkröte springen und ebenfalls left/right lässt die Schildkröte sofort drehen.

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

Zustand der Schildkröte abfragen

turtle.position()
turtle.pos()

Gibt die aktuelle Position (x,y) der Schildkröte zurück (als Vec2D-Vektor).

>>> turtle.pos()
(440.00,-0.00)
turtle.towards(x, y=None)
Parameter:

  • x – eine Zahl oder ein Paar/Vektor von Zahlen oder eine Schildkröteninstanz

  • y – eine Zahl, wenn x eine Zahl ist, sonst None

Gibt den Winkel zwischen der Linie von der Position der Schildkröte zur durch (x,y) gegebenen Position, dem Vektor oder der anderen Schildkröte zurück. Dies hängt von der Startausrichtung der Schildkröte ab, die vom Modus abhängt – „standard“/„world“ oder „logo“.

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

Gibt die x-Koordinate der Schildkröte 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()

Gibt die y-Koordinate der Schildkröte zurück.

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

Gibt die aktuelle Ausrichtung der Schildkröte zurück (Wert hängt vom Schildkrötenmodus ab, siehe mode()).

>>> turtle.home()
>>> turtle.left(67)
>>> turtle.heading()
67.0
turtle.distance(x, y=None)
Parameter:

  • x – eine Zahl oder ein Paar/Vektor von Zahlen oder eine Schildkröteninstanz

  • y – eine Zahl, wenn x eine Zahl ist, sonst None

Gibt die Entfernung von der Schildkröte zu (x,y), dem gegebenen Vektor oder der anderen Schildkröte in Schildkrötenschritt-Einheiten zurück.

>>> turtle.home()
>>> turtle.distance(30,40)
50.0
>>> turtle.distance((30,40))
50.0
>>> joe = Turtle()
>>> joe.forward(77)
>>> turtle.distance(joe)
77.0

Einstellungen für Messung

turtle.degrees(fullcircle=360.0)
Parameter:

fullcircle – eine Zahl

Legt die Einheiten für die Winkelmessung fest, d. h. legt die Anzahl der „Grad“ für einen vollen Kreis fest. Der Standardwert ist 360 Grad.

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

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

Legt die Einheiten für die Winkelmessung auf Radiant fest. Entspricht degrees(2*math.pi).

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

Stiftsteuerung

Zeichenzustand

turtle.pendown()
turtle.pd()
turtle.down()

Stift nach unten ziehen – zeichnen beim Bewegen.

turtle.penup()
turtle.pu()
turtle.up()

Stift nach oben ziehen – kein Zeichnen beim Bewegen.

turtle.pensize(width=None)
turtle.width(width=None)
Parameter:

width – eine positive Zahl

Setzt die Liniendicke auf width oder gibt sie zurück. Wenn resizemode auf „auto“ gesetzt ist und die Schildkrötenform ein Polygon ist, wird dieses Polygon mit derselben Liniendicke gezeichnet. Wenn kein Argument angegeben ist, wird die aktuelle Stiftdicke 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 Wörterbuch 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

Gibt die Attribute des Stifts als „Stift-Wörterbuch“ zurück oder setzt sie. Das Wörterbuch enthält die folgenden Schlüssel/Wert-Paare:

  • „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“ oder „user“ oder „noresize“

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

  • „outline“: positive Zahl

  • „tilt“: Zahl

Dieses Wörterbuch kann als Argument für einen nachfolgenden Aufruf von pen() verwendet werden, um den vorherigen Stiftzustand wiederherzustellen. Darüber hinaus können ein oder mehrere dieser Attribute als Schlüsselwortargumente übergeben werden. Dies kann verwendet werden, um mehrere Stiftattribute in einer Anweisung festzulegen.

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

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

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

Farbsteuerung

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

Gibt die Stiftfarbe zurück oder setzt sie.

Vier Eingabeformate sind erlaubt:

pencolor()

Gibt die aktuelle Stiftfarbe als Farbspezifikationsstring oder als Tupel (siehe Beispiel) zurück. Kann als Eingabe für einen anderen Farb-/Stift-/Füll-/Hintergrundfarbaufruf verwendet werden.

pencolor(colorstring)

Setzt die Stiftfarbe auf colorstring, einem Tk-Farbspezifikationsstring, wie z. B. "red", "yellow" oder "#33cc8c".

pencolor((r, g, b))

Setzt die Stiftfarbe auf die durch das Tupel r, g und b dargestellte RGB-Farbe. Jeder Wert von r, g und b muss im Bereich 0..colormode liegen, wobei colormode entweder 1.0 oder 255 ist (siehe colormode()).

pencolor(r, g, b)

Setzt die Stiftfarbe auf die durch r, g und b dargestellte RGB-Farbe. Jeder Wert von r, g und b muss im Bereich 0..colormode liegen.

Wenn die Schildkrötenform ein Polygon ist, wird die Umrandung dieses Polygons mit der neu eingestellten Stiftfarbe gezeichnet.

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

Gibt die Füllfarbe zurück oder setzt sie.

Vier Eingabeformate sind erlaubt:

fillcolor()

Gibt die aktuelle Füllfarbe als Farbspezifikationsstring zurück, möglicherweise im Tupelformat (siehe Beispiel). Kann als Eingabe für einen anderen Farb-/Stift-/Füll-/Hintergrundfarbaufruf verwendet werden.

fillcolor(colorstring)

Setzt die Füllfarbe auf colorstring, einem Tk-Farbspezifikationsstring, wie z. B. "red", "yellow" oder "#33cc8c".

fillcolor((r, g, b))

Setzt die Füllfarbe auf die durch das Tupel r, g und b dargestellte RGB-Farbe. Jeder Wert von r, g und b muss im Bereich 0..colormode liegen, wobei colormode entweder 1.0 oder 255 ist (siehe colormode()).

fillcolor(r, g, b)

Setzt die Füllfarbe auf die durch r, g und b dargestellte RGB-Farbe. Jeder Wert von r, g und b muss im Bereich 0..colormode liegen.

Wenn die Schildkrötenform ein Polygon ist, wird das Innere dieses Polygons mit der neu eingestellten Füllfarbe gefüllt.

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

Gibt die Stift- und Füllfarbe zurück oder setzt sie.

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

color()

Gibt die aktuelle Stiftfarbe und die aktuelle Füllfarbe als ein Paar von Farbspezifikationsstrings oder Tupeln zurück, wie von pencolor() und fillcolor() zurückgegeben.

color(colorstring), color((r,g,b)), color(r,g,b)

Eingaben wie in pencolor(), setzt sowohl Füllfarbe als auch Stiftfarbe auf den gegebenen 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.

Wenn die Schildkrötenform ein Polygon ist, werden die Umrandung und das Innere dieses Polygons mit den neu eingestellten 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: Bildschirm-Methode colormode().

Füllen

turtle.filling()

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

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

Füllt die im with turtle.fill():-Block gezeichnete Form.

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

Die Verwendung von fill() ist äquivalent zum Einfügen von begin_fill() vor dem Füllblock und end_fill() nach dem Füllblock.

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

Hinzugefügt in Version 3.14.

turtle.begin_fill()

Sollte direkt vor dem Zeichnen einer zu füllenden Form aufgerufen werden.

turtle.end_fill()

Füllt die Form, die nach dem letzten Aufruf von begin_fill() gezeichnet wurde.

Ob sich überlappende Bereiche für selbstschneidende Polygone oder mehrere 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 Schildkrötenstern oben entweder ganz gelb sein oder einige weiße Bereiche aufweisen.

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

Weitere Zeichensteuerung

turtle.reset()

Löscht die Zeichnungen der Schildkröte vom Bildschirm, zentriert die Schildkröte neu und setzt die Variablen auf die Standardwerte.

>>> turtle.goto(0,-22)
>>> turtle.left(100)
>>> turtle.position()
(0.00,-22.00)
>>> turtle.heading()
100.0
>>> turtle.reset()
>>> turtle.position()
(0.00,0.00)
>>> turtle.heading()
0.0
turtle.clear()

Löscht die Zeichnungen der Schildkröte vom Bildschirm. Die Schildkröte wird nicht bewegt. Der Zustand und die Position der Schildkröte sowie die Zeichnungen anderer Schildkröten bleiben unberührt.

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 – einer der Strings „left“, „center“ oder „right“

  • font – ein Tupel (Schriftartname, Schriftgröße, Schriftstil)

Schreibt Text – die String-Darstellung von arg – an der aktuellen Schildkrötenposition gemäß align („left“, „center“ oder „right“) und mit der angegebenen Schriftart. Wenn move True ist, wird der Stift zur unteren rechten Ecke des Textes bewegt. Standardmäßig ist move False.

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

Zustand der Schildkröte

Sichtbarkeit

turtle.hideturtle()
turtle.ht()

Macht die Schildkröte unsichtbar. Es ist ratsam, dies zu tun, wenn Sie gerade komplexe Zeichnungen erstellen, da das Ausblenden der Schildkröte die Zeichengeschwindigkeit merklich erhöht.

>>> turtle.hideturtle()
turtle.showturtle()
turtle.st()

Macht die Schildkröte sichtbar.

>>> turtle.showturtle()
turtle.isvisible()

Gibt True zurück, wenn die Schildkröte angezeigt wird, False, wenn sie ausgeblendet ist.

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

Aussehen

turtle.shape(name=None)
Parameter:

name – ein String, der ein gültiger Shapename ist

Setzt die Schildkrötenform auf die Form mit dem angegebenen name oder, wenn name nicht angegeben ist, gibt den Namen der aktuellen Form zurück. Die Form mit name muss im Shape-Dictionary des TurtleScreens existieren. Anfangs gibt es die folgenden Polygonformen: „arrow“, „turtle“, „circle“, „square“, „triangle“, „classic“. Wie man mit Formen umgeht, erfahren Sie in der Bildschirm-Methode register_shape().

>>> turtle.shape()
'classic'
>>> turtle.shape("turtle")
>>> turtle.shape()
'turtle'
turtle.resizemode(rmode=None)
Parameter:

rmode – einer der Strings „auto“, „user“, „noresize“

Setzt den Resizemodus auf einen der Werte: „auto“, „user“, „noresize“. Wenn rmode nicht angegeben ist, wird der aktuelle Resizemodus zurückgegeben. Unterschiedliche Resizemodi haben folgende Auswirkungen:

  • „auto“: passt das Aussehen der Schildkröte an den Wert von pensize an.

  • „user“: passt das Aussehen der Schildkröte entsprechend den Werten von stretchfactor und outlinewidth (outline) an, die durch shapesize() festgelegt werden.

  • „noresize“: keine Anpassung des Erscheinungsbildes der Schildkröte erfolgt.

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

Gibt die x/y-Dehnfaktoren und/oder die Umrisslinie des Stifts zurück oder setzt sie. Setzt den Resizemodus auf „user“. Nur wenn der Resizemodus auf „user“ gesetzt ist, wird die Schildkröte entsprechend ihrer Dehnfaktoren gestreckt dargestellt: stretch_wid ist der Dehnfaktor senkrecht zu ihrer Ausrichtung, stretch_len ist der Dehnfaktor in Richtung ihrer Ausrichtung, outline bestimmt die Dicke der Umrandung 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)

Setzt oder gibt den aktuellen Schiebungfaktor zurück. Schert die Schildkrötenform entsprechend dem gegebenen Schiebungfaktor shear, der der Tangens des Schiebungwinkels ist. Ändert die Ausrichtung der Schildkröte (Bewegungsrichtung) nicht. Wenn shear nicht angegeben ist: gibt den aktuellen Schiebungfaktor zurück, d. h. den Tangens des Schiebungwinkels, um den Linien parallel zur Ausrichtung der Schildkröte verschoben werden.

>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.shearfactor(0.5)
>>> turtle.shearfactor()
0.5
turtle.tilt(angle)
Parameter:

angle – eine Zahl

Dreht die Schildkrötenform um angle vom aktuellen Kippwinkel, ändert aber die Ausrichtung der Schildkröte (Bewegungsrichtung) nicht.

>>> turtle.reset()
>>> turtle.shape("circle")
>>> turtle.shapesize(5,2)
>>> turtle.tilt(30)
>>> turtle.fd(50)
>>> turtle.tilt(30)
>>> turtle.fd(50)
turtle.tiltangle(angle=None)
Parameter:

angle – eine Zahl (optional)

Setzt oder gibt den aktuellen Kippwinkel zurück. Wenn angle angegeben ist, wird die Schildkrötenform so gedreht, dass sie in die durch angle angegebene Richtung zeigt, unabhängig von ihrem aktuellen Kippwinkel. Ändert die Ausrichtung der Schildkröte (Bewegungsrichtung) nicht. Wenn angle nicht angegeben ist: gibt den aktuellen Kippwinkel zurück, d. h. den Winkel zwischen der Ausrichtung der Schildkrötenform und der Ausrichtung der Schildkröte (ihre 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)

Setzt oder gibt die aktuelle Transformationsmatrix der Turtle-Form zurück.

Wenn keine der Matrixelemente gegeben sind, wird die Transformationsmatrix als Tupel von 4 Elementen zurückgegeben. Andernfalls werden die gegebenen Elemente gesetzt und die Turtle-Form entsprechend der Matrix, die aus der ersten Zeile t11, t12 und der zweiten Zeile t21, t22 besteht, transformiert. Die Determinante t11 * t22 - t12 * t21 darf nicht Null sein, da sonst ein Fehler ausgelöst wird. Streckfaktor, Scherfaktor und Kippwinkel werden entsprechend der gegebenen Matrix modifiziert.

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

Gibt das aktuelle Form-Polygon als Tupel von Koordinatenpaaren zurück. Dies kann zur Definition einer neuen Form oder von Komponenten einer zusammengesetzten Form verwendet werden.

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

Verwendung von Ereignissen

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

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

  • btn – Nummer der Maustaste, Standard ist 1 (linke Maustaste)

  • add – True oder False – wenn True, wird eine neue Bindung hinzugefügt, andernfalls ersetzt sie eine frühere Bindung

Bindet fun an Mausklick-Ereignisse auf dieser Turtle. Wenn fun None ist, werden bestehende Bindungen entfernt. Beispiel für die anonyme Turtle, d.h. die prozedurale Methode

>>> 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 Punktes auf der Zeichenfläche aufgerufen wird

  • btn – Nummer der Maustaste, Standard ist 1 (linke Maustaste)

  • add – True oder False – wenn True, wird eine neue Bindung hinzugefügt, andernfalls ersetzt sie eine frühere Bindung

Bindet fun an Maustasten-Loslass-Ereignisse auf dieser Turtle. Wenn fun None ist, 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 Punktes auf der Zeichenfläche aufgerufen wird

  • btn – Nummer der Maustaste, Standard ist 1 (linke Maustaste)

  • add – True oder False – wenn True, wird eine neue Bindung hinzugefügt, andernfalls ersetzt sie eine frühere Bindung

Bindet fun an Mausbewegungs-Ereignisse auf dieser Turtle. Wenn fun None ist, werden bestehende Bindungen entfernt.

Hinweis: Jede Sequenz von Mausbewegungsereignissen auf einer Turtle wird einem Mausklickereignis auf dieser Turtle vorausgehen.

>>> turtle.ondrag(turtle.goto)

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

Spezielle Turtle-Methoden

turtle.poly()

Zeichnet die Eckpunkte eines Polygons, das im with turtle.poly(): Block gezeichnet wurde. Der erste und letzte Eckpunkt werden verbunden.

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

Hinzugefügt in Version 3.14.

turtle.begin_poly()

Beginnt die Aufzeichnung der Eckpunkte eines Polygons. Die aktuelle Position der Turtle ist der erste Eckpunkt des Polygons.

turtle.end_poly()

Beendet die Aufzeichnung der Eckpunkte eines Polygons. Die aktuelle Position der Turtle ist der letzte Eckpunkt des Polygons. Dieser wird mit dem ersten Eckpunkt verbunden.

turtle.get_poly()

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

Erstellt und gibt eine Kopie der Turtle mit gleicher Position, Ausrichtung und Turtle-Eigenschaften zurück.

>>> mick = Turtle()
>>> joe = mick.clone()
turtle.getturtle()
turtle.getpen()

Gibt das Turtle-Objekt selbst zurück. Nur sinnvolle Verwendung: als Funktion, um die "anonyme Turtle" zurückzugeben.

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

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

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

size – eine Ganzzahl oder None

Setzt oder deaktiviert den Undo-Puffer. Wenn size eine Ganzzahl ist, wird ein leerer Undo-Puffer mit der gegebenen Größe installiert. size gibt die maximale Anzahl von Turtle-Aktionen an, die mit der undo()-Methode/Funktion rückgängig gemacht werden können. Wenn size None ist, wird der Undo-Puffer deaktiviert.

>>> turtle.setundobuffer(42)
turtle.undobufferentries()

Gibt 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, müssen Sie die Hilfsklasse Shape explizit wie unten beschrieben verwenden

  1. Erstellt ein leeres Shape-Objekt vom Typ "compound".

  2. Fügt diesem Objekt so viele Komponenten wie gewünscht hinzu, indem die Methode addcomponent() verwendet wird.

    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ügen Sie nun die Form zur Shapelist des Screens hinzu und verwenden Sie sie

    >>> register_shape("myshape", s)
>>> shape("myshape")

Hinweis

Die Klasse Shape wird intern von der Methode register_shape() in verschiedenen Weisen verwendet. Der Anwendungsentwickler muss sich nur dann mit der Shape-Klasse befassen, wenn er zusammengesetzte Formen wie oben gezeigt verwendet!

Methoden von TurtleScreen/Screen und entsprechende Funktionen

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

Gibt die Hintergrundfarbe des TurtleScreens zurück oder setzt sie.

Vier Eingabeformate sind erlaubt:

bgcolor()

Gibt die aktuelle Hintergrundfarbe als Farb-Spezifikationsstring oder als Tupel zurück (siehe Beispiel). Kann als Eingabe für einen anderen Farb-/pencolor-/fillcolor-/bgcolor-Aufruf verwendet werden.

bgcolor(colorstring)

Setzt die Hintergrundfarbe auf colorstring, einen Tk-Farb-Spezifikationsstring wie "red", "yellow" oder "#33cc8c".

bgcolor((r, g, b))

Setzt die Hintergrundfarbe auf die RGB-Farbe, die durch das Tupel von r, g und b dargestellt wird. Jeder Wert von r, g und b muss im Bereich 0..colormode liegen, wobei colormode entweder 1.0 oder 255 ist (siehe colormode()).

bgcolor(r, g, b)

Setzt die Hintergrundfarbe auf die RGB-Farbe, die durch r, g und b dargestellt wird. Jeder Wert von r, g und b muss im Bereich 0..colormode liegen.

>>> screen.bgcolor("orange")
>>> screen.bgcolor()
'orange'
>>> screen.bgcolor("#800080")
>>> screen.bgcolor()
(128.0, 0.0, 128.0)
turtle.bgpic(picname=None)
Parameter:

picname – ein String, der Name einer Bilddatei (PNG, GIF, PGM und PPM) oder "nopic", oder None

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

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

Hinweis

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

turtle.clearscreen()

Löscht alle Zeichnungen und alle Turtles vom TurtleScreen. Setzt den nun leeren TurtleScreen in seinen Ausgangszustand zurück: weißer Hintergrund, kein Hintergrundbild, keine Ereignisbindungen und aktiver Tracing.

turtle.reset()

Hinweis

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

turtle.resetscreen()

Setzt alle Turtles auf dem Bildschirm in ihren Ausgangszustand zurück.

turtle.screensize(canvwidth=None, canvheight=None, bg=None)
Parameter:

  • canvwidth – positive Ganzzahl, neue Breite der Zeichenfläche in Pixeln

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

  • bg – Farbstring oder Farb-Tupel, neue Hintergrundfarbe

Wenn keine Argumente gegeben sind, wird die aktuelle (canvaswidth, canvasheight) zurückgegeben. Andernfalls wird die Zeichenfläche, auf der die Turtles zeichnen, vergrößert/verkleinert. Das Zeichenfenster wird dabei nicht verändert. Um verborgene Teile der Zeichenfläche zu sehen, verwenden Sie die Scrollbalken. Mit dieser Methode können Teile einer Zeichnung sichtbar gemacht werden, die sich zuvor außerhalb der Zeichenfläche befanden.

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

z.B. um eine fehlerhaft entkommene Turtle zu suchen ;-)

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

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

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

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

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

Richtet ein benutzerdefiniertes Koordinatensystem ein und wechselt bei Bedarf in den Modus "world". Dies führt ein screen.reset() durch. Wenn der Modus "world" bereits aktiv ist, werden alle Zeichnungen entsprechend den neuen Koordinaten neu gezeichnet.

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

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

Animationssteuerung

turtle.no_animation()

Deaktiviert vorübergehend die Turtle-Animation. Der Code, der innerhalb des no_animation-Blocks geschrieben wird, wird nicht animiert; sobald der Code-Block verlassen wird, erscheint die Zeichnung.

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

Hinzugefügt in Version 3.14.

turtle.delay(delay=None)
Parameter:

delay – positive Ganzzahl

Setzt oder gibt die Zeichenverzögerung (delay) in Millisekunden zurück. (Dies ist ungefähr das Zeitintervall zwischen zwei aufeinanderfolgenden Aktualisierungen der Zeichenfläche.) Je länger die Zeichenverzögerung, desto langsamer die Animation.

Optionales Argument

>>> screen.delay()
10
>>> screen.delay(5)
>>> screen.delay()
5
turtle.tracer(n=None, delay=None)
Parameter:

  • n – nicht-negative Ganzzahl

  • delay – nicht-negative Ganzzahl

Schaltet die Turtle-Animation ein/aus und setzt die Verzögerung für die Aktualisierung von Zeichnungen. Wenn n gegeben ist, wird nur jede n-te reguläre Bildschirmaktualisierung tatsächlich durchgeführt. (Kann zur Beschleunigung der Zeichnung komplexer Grafiken verwendet werden.) Wenn ohne Argumente aufgerufen, wird der aktuell gespeicherte Wert von n zurückgegeben. Das zweite Argument setzt den Verzögerungswert (siehe delay()).

>>> screen.tracer(8, 25)
>>> dist = 2
>>> for i in range(200):
...     fd(dist)
...     rt(90)
...     dist += 2
turtle.update()

Führt eine TurtleScreen-Aktualisierung durch. Muss verwendet werden, wenn tracer ausgeschaltet ist.

Siehe auch die RawTurtle/Turtle-Methode speed().

Verwendung von Screen-Ereignissen

turtle.listen(xdummy=None, ydummy=None)

Setzt den Fokus auf TurtleScreen (um Tastaturereignisse 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 – ein String: Taste (z.B. „a“) oder Tastensymbol (z.B. „space“)

Bindet fun an das Ereignis des Loslassens der Taste key. Wenn fun None ist, werden Ereignisbindungen entfernt. Hinweis: Um Tastenereignisse 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 – ein String: Taste (z.B. „a“) oder Tastensymbol (z.B. „space“)

Bindet fun an das Tastendruckereignis von key, wenn key gegeben ist, oder an jedes Tastendruckereignis, wenn kein key gegeben ist. Hinweis: Um Tastenereignisse 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 Punktes auf der Zeichenfläche aufgerufen wird

  • btn – Nummer der Maustaste, Standard ist 1 (linke Maustaste)

  • add – True oder False – wenn True, wird eine neue Bindung hinzugefügt, andernfalls ersetzt sie eine frühere Bindung

Bindet fun an Mausklick-Ereignisse auf diesem Screen. Wenn fun None ist, werden bestehende Bindungen entfernt.

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

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

Hinweis

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

turtle.ontimer(fun, t=0)
Parameter:

  • fun – eine Funktion ohne Argumente

  • t – eine Zahl >= 0

Installiert einen Timer, der fun nach t Millisekunden aufruft.

>>> running = True
>>> def f():
...     if running:
...         fd(50)
...         lt(60)
...         screen.ontimer(f, 250)
>>> f()   ### makes the turtle march around
>>> running = False
turtle.mainloop()
turtle.done()

Startet die Ereignisschleife - Aufruf von Tkinter's mainloop-Funktion. Muss die letzte Anweisung in einem Turtle-Grafikprogramm sein. Darf nicht verwendet werden, wenn ein Skript von IDLE im -n-Modus (No subprocess) ausgeführt wird - für die interaktive Verwendung von Turtle-Grafiken.

>>> screen.mainloop()

Eingabemethoden

turtle.textinput(title, prompt)
Parameter:

  • title – String

  • prompt – String

Öffnet ein Dialogfenster zur Eingabe eines Strings. Parameter title ist der Titel des Dialogfensters, prompt ist ein Text, der meist beschreibt, welche Informationen eingegeben werden sollen. Gibt den eingegebenen String zurück. Wenn der Dialog abgebrochen wird, wird None zurückgegeben.

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

Öffnet ein Dialogfenster zur Eingabe einer Zahl. title ist der Titel des Dialogfensters, prompt ist ein Text, der meist beschreibt, welche numerischen Informationen eingegeben werden sollen. default: Standardwert, minval: Mindestwert für die Eingabe, maxval: Höchstwert für die Eingabe. Die Zahleneingabe muss im Bereich minval .. maxval liegen, wenn diese angegeben sind. Andernfalls wird ein Hinweis ausgegeben und der Dialog bleibt zur Korrektur geöffnet. Gibt die eingegebene Zahl zurück. Wenn der Dialog abgebrochen wird, wird None zurückgegeben.

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

Einstellungen und spezielle Methoden

turtle.mode(mode=None)
Parameter:

mode – einer der Strings "standard", "logo" oder "world"

Setzt den Turtle-Modus ("standard", "logo" oder "world") und führt ein Reset durch. Wenn mode nicht gegeben ist, wird der aktuelle Modus zurückgegeben.

Modus "standard" ist kompatibel mit dem alten turtle. Modus "logo" ist kompatibel mit den meisten Logo-Turtle-Grafiken. Modus "world" verwendet benutzerdefinierte "Weltkoordinaten". **Achtung**: in diesem Modus erscheinen Winkel verzerrt, wenn das Verhältnis der x/y-Einheiten nicht 1 ist.

Modus

Anfängliche Turtle-Ausrichtung

positive Winkel

„standard“

nach rechts (Osten)

gegen den Uhrzeigersinn

„logo“

nach oben (Norden)

im Uhrzeigersinn

 
>>> mode("logo")   # resets turtle heading to north
>>> mode()
'logo'
turtle.colormode(cmode=None)
Parameter:

cmode – einer der Werte 1.0 oder 255

Gibt den Farbmodus zurück oder setzt ihn auf 1.0 oder 255. Anschliessend müssen die r, g, b Werte von Farb-Tripletts im Bereich 0..*cmode* liegen.

>>> screen.colormode(1)
>>> turtle.pencolor(240, 160, 80)
Traceback (most recent call last):
     ...
TurtleGraphicsError: bad color sequence: (240, 160, 80)
>>> screen.colormode()
1.0
>>> screen.colormode(255)
>>> screen.colormode()
255
>>> turtle.pencolor(240,160,80)
turtle.getcanvas()

Gibt die Zeichenfläche (Canvas) dieses TurtleScreens zurück. Nützlich für Insider, die wissen, was sie mit einer Tkinter Canvas machen sollen.

>>> cv = screen.getcanvas()
>>> cv
<turtle.ScrolledCanvas object ...>
turtle.getshapes()

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

Es gibt vier verschiedene Möglichkeiten, diese Funktion aufzurufen

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

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

    Hinweis

    Bildformen drehen sich beim Drehen der Turtle *nicht*, daher zeigen sie nicht die Ausrichtung der Turtle an!

  2. name ist ein beliebiger String und shape ist der Name einer Bilddatei (PNG, GIF, PGM und PPM): Installiert die entsprechende Bildform.

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

    Hinweis

    Bildformen drehen sich beim Drehen der Turtle *nicht*, daher zeigen sie nicht die Ausrichtung der Turtle an!

  3. name ist ein beliebiger String und shape ist ein Tupel von Koordinatenpaaren: Installiert die entsprechende Polygonform.

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

  4. name ist ein beliebiger String und shape ist ein (zusammengesetztes) Shape-Objekt: Installiert die entsprechende zusammengesetzte Form.

Fügt eine Schildkrötenform zur shapelist von TurtleScreen hinzu. Nur auf diese Weise registrierte Formen können durch den Befehl shape(shapename) verwendet werden.

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

turtle.turtles()

Gibt die Liste der Schildkröten auf dem Bildschirm zurück.

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

Gibt die Höhe des Schildkrötenfensters zurück.

>>> screen.window_height()
480
turtle.window_width()

Gibt die Breite des Schildkrötenfensters zurück.

>>> screen.window_width()
640

Methoden, die spezifisch für Screen sind und nicht von TurtleScreen geerbt wurden

turtle.bye()

Schließt das Schildkrötengrafikfenster.

turtle.exitonclick()

Bindet die `bye()`-Methode an Mausklicks auf den Bildschirm.

Wenn der Wert "using_IDLE" im Konfigurationswörterbuch `False` (Standardwert) ist, wird auch die mainloop gestartet. Hinweis: Wenn IDLE mit dem `-n` Schalter (no subprocess) verwendet wird, sollte dieser Wert in `turtle.cfg` auf `True` gesetzt werden. In diesem Fall ist die eigene mainloop von IDLE auch für das Client-Skript aktiv.

turtle.save(filename, overwrite=False)

Speichert die aktuelle Schildkrötenzeichnung (und Schildkröten) als PostScript-Datei.

Parameter:

  • filename – der Pfad der gespeicherten PostScript-Datei

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

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

Hinzugefügt in Version 3.14.

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

Setzt die Größe und Position des Hauptfensters. Standardwerte der Argumente werden im Konfigurationswörterbuch gespeichert und können über eine `turtle.cfg`-Datei geändert werden.

Parameter:

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

  • height – wenn eine Ganzzahl, die Höhe in Pixeln, wenn eine Gleitkommazahl, ein Bruchteil des Bildschirms; Standard ist 75% des Bildschirms

  • startx – wenn positiv, Startposition in Pixeln vom linken Rand des Bildschirms, wenn negativ vom rechten Rand, wenn `None`, Fenster horizontal zentrieren

  • starty – wenn positiv, Startposition in Pixeln vom oberen Rand des Bildschirms, wenn negativ vom unteren Rand, wenn `None`, Fenster vertikal zentrieren

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

titlestring – eine Zeichenkette, die in der Titelleiste des Schildkrötengrafikfensters angezeigt wird

Setzt den Titel des Schildkrötenfensters auf `titlestring`.

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

Öffentliche Klassen

class turtle.RawTurtle(canvas)
class turtle.RawPen(canvas)
Parameter:

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

Erstellt eine Schildkröte. Die Schildkröte hat alle oben als „Methoden von Turtle/RawTurtle“ beschriebenen Methoden.

class turtle.Turtle

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

class turtle.TurtleScreen(cv)
Parameter:

cv – ein tkinter.Canvas

Bietet bildschirmorientierte Methoden wie `bgcolor()` etc., die oben beschrieben sind.

class turtle.Screen

Unterklasse von TurtleScreen, mit vier hinzugefügten Methoden.

class turtle.ScrolledCanvas(master)
Parameter:

master – ein Tkinter-Widget, das den ScrolledCanvas enthält, d.h. ein Tkinter-Canvas mit hinzugefügten Scrollbars

Wird von der Klasse Screen verwendet, die somit automatisch einen ScrolledCanvas als Spielfeld für die Schildkröten bereitstellt.

class turtle.Shape(type_, data)
Parameter:

type_ – einer der Zeichenketten „polygon“, „image“, „compound“

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

type_

Daten

„polygon“

ein Polygon-Tupel, d.h. ein Tupel von Koordinatenpaaren

„image“

ein Bild (in dieser Form nur intern verwendet!)

„compound“

`None` (eine zusammengesetzte Form muss mit der Methode `addcomponent()` erstellt werden)
addcomponent(poly, fill, outline=None)
Parameter:

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

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

  • outline – eine Farbe für die Umrandung des `poly` (falls angegeben)

Beispiel

>>> poly = ((0,0),(10,-5),(0,10),(-10,-5))
>>> s = Shape("compound")
>>> s.addcomponent(poly, "red", "blue")
>>> # ... add more components and then use register_shape()

Siehe Zusammengesetzte Formen.

class turtle.Vec2D(x, y)

Eine zweidimensionale Vektorklasse, die als Hilfsklasse zur Implementierung von Schildkrötengrafiken dient. Kann auch für Schildkrötengrafikprogramme nützlich sein. Abgeleitet von tuple, also ist ein Vektor ein Tupel!

Bietet (für Vektoren `a`, `b`, Skalar `k`)

  • a + b Vektoraddition

  • a - b Vektorsubtraktion

  • a * b Skalarprodukt

  • k * a und `a * k` Multiplikation mit Skalar

  • abs(a) Betrag eines Vektors

  • a.rotate(angle) Rotation

Erklärung

Ein Schildkrötenobjekt zeichnet auf einem Bildschirmobjekt, und es gibt eine Reihe von Schlüsselklassen in der objektorientierten Schnittstelle von Schildkröten, die verwendet werden können, um sie zu erstellen und sie zueinander in Beziehung zu setzen.

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

`Turtle` ist eine Unterklasse von `RawTurtle`, die *keine* Zeichenfläche automatisch erstellt – eine `canvas` muss ihr bereitgestellt oder für sie erstellt werden. Die `canvas` kann ein `tkinter.Canvas`, ein `ScrolledCanvas` oder ein `TurtleScreen` sein.

`TurtleScreen` ist die grundlegende Zeichenfläche für eine Schildkröte. `Screen` ist eine Unterklasse von `TurtleScreen` und enthält einige zusätzliche Methoden zur Verwaltung ihres Aussehens (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 Schildkrötengrafiken verwendet die verschiedenen Methoden von `Turtle` und `TurtleScreen`/`Screen`. Im Hintergrund wird ein Bildschirmobjekt automatisch erstellt, wann immer eine Funktion aufgerufen wird, die von einer `Screen`-Methode abgeleitet ist. Ebenso wird ein Schildkrötenobjekt automatisch erstellt, wann immer eine der Funktionen aufgerufen wird, die von einer Turtle-Methode abgeleitet ist.

Um mehrere Schildkröten auf einem Bildschirm zu verwenden, muss die objektorientierte Schnittstelle verwendet werden.

Hilfe und Konfiguration

Wie man Hilfe benutzt

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

  • Bei der Verwendung von IDLE zeigen Tooltips die Signaturen und ersten Zeilen der Docstrings von eingegebenen Funktions-/Methodenaufrufen an.

  • Das Aufrufen von `help()` auf 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 modifizierte 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 modifizierten Docstrings werden automatisch zusammen mit den Funktionsdefinitionen erstellt, die beim Import zur Laufzeit von den Methoden abgeleitet werden.

Übersetzung von Docstrings in verschiedene Sprachen

Es gibt ein Hilfsprogramm, um ein Wörterbuch 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 – ein String, der als Dateiname verwendet wird

Erstellt und schreibt ein Docstring-Wörterbuch in ein Python-Skript mit dem angegebenen Dateinamen. Diese Funktion muss explizit aufgerufen werden (sie wird nicht von den Schildkrötengrafikklassen verwendet). Das Docstring-Wörterbuch wird in das Python-Skript `filename.py` geschrieben. Es soll als Vorlage für die Übersetzung der Docstrings in verschiedene Sprachen dienen.

Wenn Sie (oder Ihre Studenten) `turtle` mit Online-Hilfe in Ihrer Muttersprache verwenden möchten, müssen Sie die Docstrings übersetzen und die resultierende Datei z. B. als `turtle_docstringdict_german.py` speichern.

Wenn Sie einen entsprechenden Eintrag in Ihrer `turtle.cfg`-Datei haben, wird dieses Wörterbuch beim Import geladen und ersetzt die ursprünglichen englischen Docstrings.

Zum Zeitpunkt der Erstellung dieses Dokuments gibt es Docstring-Wörterbücher in deutscher und italienischer Sprache. (Anfragen bitte an `glingl@aon.at`.)

Wie man Screen und Turtles konfiguriert

Die integrierte Standardkonfiguration ahmt das Aussehen und Verhalten des alten Turtle-Moduls nach, um die bestmögliche Kompatibilität damit zu erhalten.

Wenn Sie eine andere Konfiguration verwenden möchten, die die Funktionen dieses Moduls besser widerspiegelt oder besser auf Ihre Bedürfnisse zugeschnitten ist, z. B. für den Einsatz im Unterricht, können Sie eine Konfigurationsdatei `turtle.cfg` vorbereiten, die beim Import gelesen wird und die Konfiguration entsprechend ihren 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 `Screen.setup()`-Methode.

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

  • shape kann jede der integrierten Formen sein, z. B.: arrow, turtle, etc. Für weitere Informationen versuchen Sie `help(shape)`.

  • Wenn Sie keine Füllfarbe verwenden möchten (d.h. die Schildkröte transparent machen), müssen Sie `fillcolor = ""` schreiben (aber alle nicht-leeren Zeichenketten dürfen keine Anführungszeichen in der cfg-Datei haben).

  • Wenn Sie den Zustand der Schildkröte widerspiegeln möchten, müssen Sie `resizemode = auto` verwenden.

  • Wenn Sie z.B. `language = italian` setzen, wird das Docstringdict `turtle_docstringdict_italian.py` beim Import geladen (wenn es im Importpfad vorhanden ist, z. B. im selben Verzeichnis wie `turtle`).

  • Die Einträge exampleturtle und examplescreen definieren die Namen dieser Objekte, wie sie in den Docstrings vorkommen. Die Transformation von Methoden-Docstrings in Funktions-Docstrings wird diese Namen aus den Docstrings entfernen.

  • using_IDLE: Setzen Sie dies auf `True`, wenn Sie regelmäßig mit IDLE und seinem `-n` Schalter („no subprocess“) arbeiten. Dies verhindert, dass `exitonclick()` die mainloop startet.

Es kann eine `turtle.cfg`-Datei im Verzeichnis geben, in dem `turtle` gespeichert ist, und eine weitere im aktuellen Arbeitsverzeichnis. Letztere überschreibt die Einstellungen der ersten.

Das Verzeichnis `Lib/turtledemo` enthält eine `turtle.cfg`-Datei. Sie können sie als Beispiel studieren und ihre Auswirkungen sehen, wenn Sie die Demos ausführen (vorzugsweise nicht aus dem Demo-Viewer heraus).

turtledemo — Demo-Skripte

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

python -m turtledemo

Alternativ können Sie die Demo-Skripte einzeln ausführen. Zum Beispiel,

python -m turtledemo.bytedesign

Das Verzeichnis des Pakets `turtledemo` enthält

  • Einen Demo-Viewer `__main__.py`, der verwendet werden kann, um den Quellcode der Skripte anzuzeigen und sie gleichzeitig auszuführen.

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

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

Die Demo-Skripte sind

Name

Beschreibung

Features

bytedesign

komplexes klassisches Schildkrötengrafikmuster

tracer(), delay, update()

chaos

graphische Darstellung der Verhulst-Dynamik, zeigt, dass Computerberechnungen Ergebnisse liefern können, die manchmal den Erwartungen widersprechen

Weltkoordinaten

clock

analoge Uhr, die die Zeit Ihres Computers anzeigt

Schildkröten als Uhrzeiger, ontimer

colormixer

Experimentieren mit r, g, b

ondrag()

forest

3 Breitensuche-Bäume

Randomisierung

fractalcurves

Hilbert- und Koch-Kurven

Rekursion

lindenmayer

Ethnomathematik (indische Kolams)

L-System

minimal_hanoi

Türme von Hanoi

Rechteckige Schildkröten als Hanoi-Scheiben (shape, shapesize)

nim

Spielen Sie das klassische Nim-Spiel mit drei Stockwerkern gegen den Computer.

Schildkröten als Nim-Sticks, ereignisgesteuert (Maus, Tastatur)

paint

super minimalistisches Zeichenprogramm

onclick()

peace

elementar

Schildkröte: Aussehen 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 Schildkrötengrafiken

clone(), undo()

round_dance

tanzende Schildkröten, die paarweise in entgegengesetzter Richtung rotieren

zusammengesetzte Formen, clone shapesize, tilt, get_shapepoly, update

sorting_animate

visuelle Demonstration verschiedener Sortiermethoden

einfache Ausrichtung, Randomisierung

tree

ein (grafischer) Breitensuche-Baum (mit Generatoren)

clone()

two_canvases

einfaches Design

Schildkröten auf zwei Leinwänden

yinyang

weiteres elementares Beispiel

circle()

Viel Spaß!

Änderungen seit Python 2.6

  • Die Methoden `Turtle.tracer`, `Turtle.window_width` und `Turtle.window_height` wurden entfernt. Methoden mit diesen Namen und Funktionalitäten sind jetzt nur noch als Methoden von `Screen` verfügbar. Die von diesen abgeleiteten Funktionen bleiben verfügbar. (Tatsächlich waren diese Methoden schon in Python 2.6 lediglich Duplikate der entsprechenden Methoden von `TurtleScreen`/`Screen`.)

  • Die Methode `Turtle.fill()` wurde entfernt. Das Verhalten von `begin_fill()` und `end_fill()` hat sich geringfügig geändert: Jetzt muss jeder Füllvorgang mit einem `end_fill()`-Aufruf abgeschlossen werden.

  • Eine Methode `Turtle.filling` wurde hinzugefügt. Sie gibt einen booleschen Wert zurück: `True`, wenn ein Füllvorgang läuft, `False` sonst. Dieses Verhalten entspricht einem `fill()`-Aufruf ohne Argumente in Python 2.6.

Änderungen seit Python 3.0

  • Die `Turtle`-Methoden `shearfactor()`, `shapetransform()` und `get_shapepoly()` wurden hinzugefügt. Somit ist nun der volle Umfang linearer Transformationen für die Transformation von Schildkrötenformen verfügbar. `tiltangle()` wurde funktional erweitert: Sie kann nun zum Abrufen oder Setzen des Neigungswinkels verwendet werden.

  • Die `Screen`-Methode `onkeypress()` wurde als Ergänzung zu `onkey()` hinzugefügt. Da letztere Aktionen an das Loslassen einer Taste bindet, wurde für sie auch ein Alias: `onkeyrelease()` hinzugefügt.

  • Die Methode `Screen.mainloop()` wurde hinzugefügt, so dass die eigenständige Funktion `mainloop()` bei der Arbeit mit `Screen`- und `Turtle`-Objekten nicht mehr benötigt wird.

  • Zwei Eingabemethoden wurden hinzugefügt: `Screen.textinput()` und `Screen.numinput()`. Diese öffnen Eingabedialoge und geben Strings bzw. Zahlen zurück.