"turtle" --- Turtle-Grafik
**************************

**Quellcode:** Lib/turtle.py

======================================================================


Turtle star
^^^^^^^^^^^

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

[Bild: A yellow starburst of thin spikes with a red outline, drawn by
turtle.][Bild]

Imagine a robotic turtle starting at (0, 0) in the x-y plane. After an
"import turtle", give it the command "turtle.forward(15)", and it
moves (on-screen!) 15 pixels in the direction it is facing, drawing a
line as it moves. Give it the command "turtle.right(25)", and it
rotates in-place 25 degrees clockwise.

Turtle graphics is an implementation of the drawing tools introduced
in Logo in 1967. It was created as an educational tool, and its
instant, visible feedback makes it an effective way for learners to
encounter programming concepts. It is also a convenient way to produce
simple graphical output without bringing in external libraries.

This document includes four main sections:

* Tutorial teaches the basics of turtle drawing.

* Reference describes the functions, methods and classes this module
  defines.

* How-to guides detail how to handle specific tasks.

* Erklärung provides background on the object-oriented interface.

Bemerkung:

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


Tutorial
========

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


Eine Turtle-Umgebung starten
----------------------------

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

   from turtle import *

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


Einfaches Zeichnen
------------------

Schicke die Turtle 100 Schritte vorwärts:

   forward(100)

Du solltest (höchstwahrscheinlich in einem neuen Fenster auf deinem
Bildschirm) eine von der Turtle gezeichnete Linie sehen, die nach
Osten zeigt. Ändere die Richtung der Turtle, sodass sie sich um 120
Grad nach links dreht (gegen den Uhrzeigersinn):

   left(120)

Lass uns fortfahren, indem wir ein Dreieck zeichnen:

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

Beachte, wie die Turtle, dargestellt durch einen Pfeil, in
unterschiedliche Richtungen zeigt, während du sie steuerst.

Experiment with those commands, and also with "backward()" and
"right()". Many commands also have shorter aliases, such as "fd()" for
"forward()".


Stiftsteuerung
~~~~~~~~~~~~~~

Versuche, die Farbe zu ändern – zum Beispiel "color('blue')" – sowie
die Breite der Linie – zum Beispiel "width(3)" – und zeichne dann
erneut.

Du kannst die Turtle auch bewegen, ohne zu zeichnen, indem du den
Stift anhebst: "up()" vor dem Bewegen. Um wieder mit dem Zeichnen zu
beginnen, verwende "down()".


Die Position der Turtle
~~~~~~~~~~~~~~~~~~~~~~~

Schicke deine Turtle zurück zu ihrem Startpunkt (nützlich, falls sie
außerhalb des Bildschirms verschwunden ist):

   home()

Die Home-Position befindet sich in der Mitte des Turtle-Bildschirms.
Falls du sie jemals wissen musst, erhältst du die x-y-Koordinaten der
Turtle mit:

   pos()

Home liegt bei "(0, 0)".

Und nach einer Weile wird es wahrscheinlich helfen, das Fenster zu
leeren, damit wir von vorne beginnen können:

   clearscreen()


Algorithmische Muster erstellen
-------------------------------

Mithilfe von Schleifen ist es möglich, geometrische Muster aufzubauen:

   for steps in range(100):
       for c in ('blue', 'red', 'green'):
           color(c)
           forward(steps)
           right(30)

- die natürlich nur durch die Fantasie begrenzt werden!

Lass uns die Sternform am Anfang dieser Seite zeichnen. Wir wollen
rote Linien, gefüllt mit Gelb:

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

Genau wie "up()" und "down()" bestimmen, ob Linien gezeichnet werden,
kann das Füllen ein- und ausgeschaltet werden:

   begin_fill()

Als Nächstes erstellen wir eine Schleife:

   start = pos()

   while True:
       forward(200)
       left(170)
       if distance(start) < 1:
           break

"distance(start) < 1" ist eine gute Möglichkeit zu erkennen, wann die
Turtle wieder an ihrer Startposition ist.

Schließlich vervollständige das Füllen:

   end_fill()

(Beachte, dass das Füllen erst tatsächlich stattfindet, wenn du den
Befehl "end_fill()" gibst.)


Reference
=========


Turtle methods and functions
----------------------------

Turtle-Instanz namens "turtle".


Bewegen und zeichnen
~~~~~~~~~~~~~~~~~~~~

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

   Parameter:
      **distance** -- eine Zahl

   Bewege die Turtle um die angegebene *distance* vorwärts, in die
   Richtung, in die die Turtle blickt.

      >>> turtle.position()
      (0.00,0.00)
      >>> turtle.forward(25)
      >>> turtle.position()
      (25.00,0.00)
      >>> turtle.forward(-75)
      >>> turtle.position()
      (-50.00,0.00)

turtle.back(distance)
turtle.bk(distance)
turtle.backward(distance)

   Parameter:
      **distance** -- eine Zahl

   Move the turtle backward by *distance*, opposite to the direction
   the turtle is headed. The turtle's heading does not change.

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

turtle.right(angle)
turtle.rt(angle)

   Parameter:
      **angle** -- eine Zahl

   Turn the turtle right by the specified *angle*. The angle is
   measured in degrees by default; the unit can be changed with
   "degrees()" or "radians()". How the heading is measured depends on
   the turtle mode, see "mode()".

      >>> turtle.heading()
      22.0
      >>> turtle.right(45)
      >>> turtle.heading()
      337.0

turtle.left(angle)
turtle.lt(angle)

   Parameter:
      **angle** -- eine Zahl

   Turn the turtle left by the specified *angle*. The angle is
   measured in degrees by default; the unit can be changed with
   "degrees()" or "radians()". How the heading is measured depends on
   the turtle mode, see "mode()".

      >>> turtle.heading()
      22.0
      >>> turtle.left(45)
      >>> turtle.heading()
      67.0

turtle.goto(x, y=None)
turtle.setpos(x, y=None)
turtle.setposition(x, y=None)

   Parameter:
      * **x** -- eine Zahl oder ein Paar/Vektor von Zahlen

      * **y** -- eine Zahl oder "None"

   Move the turtle to an absolute position. If *y* is "None", *x* must
   be a pair of coordinates or a "Vec2D", for example as returned by
   "pos()". If the pen is down, a line is drawn. The turtle's heading
   does not change.

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

turtle.teleport(x, y=None, *, fill_gap=False)

   Parameter:
      * **x** -- eine Zahl oder "None"

      * **y** -- eine Zahl oder "None"

      * **fill_gap** -- Ein Boolean

   Bewege die Turtle zu einer absoluten Position. Im Gegensatz zu
   goto(x, y) wird dabei keine Linie gezeichnet. Die Ausrichtung der
   Turtle ändert sich nicht. Falls gerade gefüllt wird, wird das
   Polygon, von dem aus teleportiert wurde, nach dem Verlassen
   gefüllt, und das Füllen beginnt nach dem Teleportieren erneut. Dies
   kann mit fill_gap=True deaktiviert werden, wodurch die gedachte
   Linie, die während des Teleportierens zurückgelegt wird, wie bei
   goto(x, y) als Füllbarriere wirkt.

      >>> tp = turtle.pos()
      >>> tp
      (0.00,0.00)
      >>> turtle.teleport(60)
      >>> turtle.pos()
      (60.00,0.00)
      >>> turtle.teleport(y=10)
      >>> turtle.pos()
      (60.00,10.00)
      >>> turtle.teleport(20, 30)
      >>> turtle.pos()
      (20.00,30.00)

   Added in version 3.12.

turtle.setx(x)

   Parameter:
      **x** -- eine Zahl

   Set the turtle's x coordinate to *x*. The y coordinate is
   unchanged.

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

turtle.sety(y)

   Parameter:
      **y** -- eine Zahl

   Set the turtle's y coordinate to *y*. The x coordinate is
   unchanged.

      >>> turtle.position()
      (0.00,40.00)
      >>> turtle.sety(-10)
      >>> turtle.position()
      (0.00,-10.00)

turtle.setheading(to_angle)
turtle.seth(to_angle)

   Parameter:
      **to_angle** -- eine Zahl

   Set the turtle's heading to *to_angle*. Here are some common
   directions in degrees:

   +---------------------+----------------------+
   | Standardmodus       | Logo-Modus           |
   |=====================|======================|
   | 0 - Ost             | 0 - Nord             |
   +---------------------+----------------------+
   | 90 - Nord           | 90 - Ost             |
   +---------------------+----------------------+
   | 180 - West          | 180 - Süd            |
   +---------------------+----------------------+
   | 270 - Süd           | 270 - West           |
   +---------------------+----------------------+

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

turtle.home()

   Move the turtle to the origin, coordinates (0,0). The turtle's
   heading is set to its start orientation, which depends on the
   turtle mode, see "mode()".

      >>> turtle.heading()
      90.0
      >>> turtle.position()
      (0.00,-10.00)
      >>> turtle.home()
      >>> turtle.position()
      (0.00,0.00)
      >>> turtle.heading()
      0.0

turtle.circle(radius, extent=None, steps=None)

   Parameter:
      * **radius** -- eine Zahl

      * **extent** -- eine Zahl oder "None"

      * **steps** -- eine Ganzzahl oder "None"

   Draw a circle with the given *radius*. The center is *radius* units
   left of the turtle; *extent*, an angle, determines which part of
   the circle is drawn. If *extent* is not given, draw the entire
   circle. If *extent* is not a full circle, one endpoint of the arc
   is the current pen position. Draw the arc in counterclockwise
   direction if *radius* is positive, otherwise in clockwise
   direction. Finally, the turtle's heading is changed by *extent*.

   As the circle is approximated by an inscribed regular polygon,
   *steps* determines the number of steps to use. If not given, it
   will be calculated automatically. May be used to draw regular
   polygons.

      >>> turtle.home()
      >>> turtle.position()
      (0.00,0.00)
      >>> turtle.heading()
      0.0
      >>> turtle.circle(50)
      >>> turtle.position()
      (-0.00,0.00)
      >>> turtle.heading()
      0.0
      >>> turtle.circle(120, 180)  # draw a semicircle
      >>> turtle.position()
      (0.00,240.00)
      >>> turtle.heading()
      180.0

turtle.dot()
turtle.dot(size)
turtle.dot(color, /)
turtle.dot(size, color, /)
turtle.dot(size, r, g, b, /)

   Parameter:
      * **size** -- eine Ganzzahl >= 1 (falls angegeben)

      * **color** -- ein Farbstring oder ein numerisches Farb-Tupel

   Zeichne einen kreisförmigen Punkt mit dem Durchmesser *size* in der
   Farbe *color*. Wird *size* nicht angegeben, wird das Maximum aus
   "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()

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

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

turtle.clearstamp(stampid)

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

   Lösche den Stempel mit der angegebenen *stampid*.

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

turtle.clearstamps(n=None)

   Parameter:
      **n** -- eine Ganzzahl (oder "None")

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

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

turtle.undo()

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

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

turtle.speed(speed=None)

   Parameter:
      **speed** -- 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 of the line from the turtle's position to (x,y).
   If *y* is "None", *x* must be a pair of coordinates, a "Vec2D", for
   example as returned by "pos()", or another turtle. The angle is
   measured from the turtle's start orientation, which depends on the
   turtle mode, see "mode()".

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

turtle.xcor()

   Gib die x-Koordinate der Turtle zurück.

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

turtle.ycor()

   Gib die y-Koordinate der Turtle zurück.

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

turtle.heading()

   Return the turtle's current heading. The value depends on the
   turtle mode, see "mode()".

      >>> turtle.home()
      >>> turtle.left(67)
      >>> turtle.heading()
      67.0

turtle.distance(x, y=None)

   Parameter:
      * **x** -- eine Zahl oder ein Paar/Vektor von Zahlen oder eine
        Turtle-Instanz

      * **y** -- eine Zahl, falls *x* eine Zahl ist, andernfalls
        "None"

   Return the distance from the turtle to (x,y) in turtle step units.
   If *y* is "None", *x* must be a pair of coordinates, a "Vec2D", for
   example as returned by "pos()", or another turtle.

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


Einstellungen für Messungen
~~~~~~~~~~~~~~~~~~~~~~~~~~~

turtle.degrees(fullcircle=360.0)

   Parameter:
      **fullcircle** -- eine Zahl

   Set the angle measurement units to degrees. The number of degrees
   in a full circle is set to *fullcircle*, which defaults to 360.

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

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

turtle.radians()

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

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


Stiftsteuerung
~~~~~~~~~~~~~~


Zeichenzustand
""""""""""""""

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

   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.pensize()
      1
      >>> turtle.pensize(10)   # from here on lines of width 10 are drawn


Farbkontrolle
"""""""""""""

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

   Gib die Stiftfarbe zurück oder setze sie.

   Vier Eingabeformate sind erlaubt:

   "pencolor()"
      Gib die aktuelle Stiftfarbe als Farbangabe-String oder als Tupel
      zurück (siehe Beispiel). Kann als Eingabe für einen weiteren
      color/pencolor/fillcolor/bgcolor-Aufruf verwendet werden.

   "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()
turtle.fillcolor(color, /)
turtle.fillcolor(r, g, b, /)

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

   Vier Eingabeformate sind erlaubt:

   "fillcolor()"
      Gib die aktuelle Füllfarbe als Farbangabe-String zurück,
      möglicherweise im Tupel-Format (siehe Beispiel). Kann als
      Eingabe für einen weiteren color/pencolor/fillcolor/bgcolor-
      Aufruf verwendet werden.

   "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()
turtle.color(color, /)
turtle.color(r, g, b, /)
turtle.color(pencolor, fillcolor, /)

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

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

   "color()"
      Gib die aktuelle Stiftfarbe und die aktuelle Füllfarbe als Paar
      von Farbangabe-Strings oder Tupeln zurück, wie sie von
      "pencolor()" und "fillcolor()" zurückgegeben werden.

   "color(colorstring)", "color((r,g,b))", "color(r,g,b)"
      Eingaben wie bei "pencolor()", setzt sowohl fillcolor als auch
      pencolor auf den angegebenen Wert.

   "color(colorstring1, colorstring2)", "color((r1,g1,b1),
   (r2,g2,b2))"
      Entspricht "pencolor(colorstring1)" und
      "fillcolor(colorstring2)" und analog, wenn das andere
      Eingabeformat verwendet wird.

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

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

Siehe auch: Screen-Methode "colormode()".


Füllen
""""""

turtle.filling()

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

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

turtle.begin_fill()

   Muss unmittelbar vor dem Zeichnen einer zu füllenden Form
   aufgerufen werden.

turtle.end_fill()

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

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

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


Mehr Zeichenkontrolle
"""""""""""""""""""""

turtle.reset()

   Lösche die Zeichnungen der Turtle vom Bildschirm, zentriere die
   Turtle neu und setze die Variablen auf ihre Standardwerte zurück.

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

turtle.clear()

   Lösche die Zeichnungen der Turtle vom Bildschirm, zentriere die
   Turtle neu und setze die Variablen auf ihre Standardwerte zurück.

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

   Parameter:
      * **arg** -- Objekt, das auf den TurtleScreen geschrieben werden
        soll

      * **move** -- True/False

      * **align** -- eine der Zeichenketten "left", "center" oder
        "right"

      * **font** -- ein Tripel (fontname, fontsize, fonttype)

   Schreibe Text – die String-Darstellung von *arg* – an die aktuelle
   Position der Turtle entsprechend *align* ("left", "center" oder
   "right") und mit der angegebenen Schriftart. Ist *move* wahr, wird
   der Stift an die untere rechte Ecke des Textes bewegt.
   Standardmäßig ist *move* "False".

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


Turtle-Status
~~~~~~~~~~~~~


Sichtbarkeit
""""""""""""

turtle.hideturtle()
turtle.ht()

   Mache die Turtle unsichtbar. Es ist eine gute Idee, dies während
   einer komplexen Zeichnung zu tun, da das Verstecken der Turtle das
   Zeichnen merklich beschleunigt.

      >>> turtle.hideturtle()

turtle.showturtle()
turtle.st()

   Mache die Turtle sichtbar.

      >>> turtle.showturtle()

turtle.isvisible()

   Gib "True" zurück, wenn die Turtle sichtbar ist, "False", wenn sie
   versteckt ist.

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


Erscheinungsbild
""""""""""""""""

turtle.shape(name=None)

   Parameter:
      **name** -- eine Zeichenkette, die ein gültiger Formname ist

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

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

turtle.resizemode(rmode=None)

   Parameter:
      **rmode** -- eine der Zeichenketten "auto", "user", "noresize"

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

   * "auto": passt das Erscheinungsbild der Turtle entsprechend dem
     Wert von pensize an.

   * "user": passt das Erscheinungsbild der Turtle gemäß den Werten
     von stretchfactor und outlinewidth (outline) an, die durch
     "shapesize()" gesetzt werden.

   * "noresize": es findet keine Anpassung des Erscheinungsbilds der
     Turtle statt.

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

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

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

   Parameter:
      * **stretch_wid** -- Positive Zahl

      * **stretch_len** -- Positive Zahl

      * **outline** -- Positive Zahl

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

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

turtle.shearfactor(shear=None)

   Parameter:
      **shear** -- Zahl (optional)

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

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

turtle.tilt(angle)

   Parameter:
      **angle** -- eine Zahl

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

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

turtle.tiltangle(angle=None)

   Parameter:
      **angle** -- eine Zahl (optional)

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

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

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

   Parameter:
      * **t11** -- eine Zahl (optional)

      * **t12** -- eine Zahl (optional)

      * **t21** -- eine Zahl (optional)

      * **t12** -- eine Zahl (optional)

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

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

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

turtle.get_shapepoly()

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

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


Ereignisse verwenden
~~~~~~~~~~~~~~~~~~~~

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

   Parameter:
      * **fun** -- eine Funktion mit zwei Argumenten, die mit den
        Koordinaten des angeklickten Punkts auf der Zeichenfläche
        aufgerufen wird

      * **btn** -- Nummer der Maustaste, standardmäßig 1 (linke
        Maustaste)

      * **add** -- "True" oder "False" -- ist es "True", wird eine
        neue Bindung hinzugefügt, andernfalls ersetzt sie eine
        vorherige Bindung

   Binde *fun* an Mausklick-Ereignisse dieser Turtle. Ist *fun*
   "None", werden bestehende Bindungen entfernt. Beispiel für die
   anonyme Turtle, d. h. die prozedurale Vorgehensweise:

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

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

   Parameter:
      * **fun** -- eine Funktion mit zwei Argumenten, die mit den
        Koordinaten des angeklickten Punkts auf der Zeichenfläche
        aufgerufen wird

      * **btn** -- Nummer der Maustaste, standardmäßig 1 (linke
        Maustaste)

      * **add** -- "True" oder "False" -- ist es "True", wird eine
        neue Bindung hinzugefügt, andernfalls ersetzt sie eine
        vorherige Bindung

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

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

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

   Parameter:
      * **fun** -- eine Funktion mit zwei Argumenten, die mit den
        Koordinaten des angeklickten Punkts auf der Zeichenfläche
        aufgerufen wird

      * **btn** -- Nummer der Maustaste, standardmäßig 1 (linke
        Maustaste)

      * **add** -- "True" oder "False" -- ist es "True", wird eine
        neue Bindung hinzugefügt, andernfalls ersetzt sie eine
        vorherige Bindung

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

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

      >>> turtle.ondrag(turtle.goto)

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


Spezielle Turtle-Methoden
~~~~~~~~~~~~~~~~~~~~~~~~~

turtle.begin_poly()

   Beginne mit dem Aufzeichnen der Eckpunkte eines Polygons. Die
   aktuelle Position der Turtle ist der erste Eckpunkt des Polygons.

turtle.end_poly()

   Beende das Aufzeichnen der Eckpunkte eines Polygons. Die aktuelle
   Position der Turtle ist der letzte Eckpunkt des Polygons. Dieser
   wird mit dem ersten Eckpunkt verbunden.

turtle.get_poly()

   Gib das zuletzt aufgezeichnete Polygon zurück.

      >>> turtle.home()
      >>> turtle.begin_poly()
      >>> turtle.fd(100)
      >>> turtle.left(20)
      >>> turtle.fd(30)
      >>> turtle.left(60)
      >>> turtle.fd(50)
      >>> turtle.end_poly()
      >>> p = turtle.get_poly()
      >>> register_shape("myFavouriteShape", p)

turtle.clone()

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

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

turtle.getturtle()
turtle.getpen()

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

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

turtle.getscreen()

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

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

turtle.setundobuffer(size)

   Parameter:
      **size** -- eine Ganzzahl oder "None"

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

      >>> turtle.setundobuffer(42)

turtle.undobufferentries()

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

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


Zusammengesetzte Formen
~~~~~~~~~~~~~~~~~~~~~~~

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

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

2. Füge diesem Objekt beliebig viele Komponenten hinzu, indem du die
   Methode "addcomponent()" verwendest.

   Zum Beispiel:

      >>> s = Shape("compound")
      >>> poly1 = ((0,0),(10,-5),(0,10),(-10,-5))
      >>> s.addcomponent(poly1, "red", "blue")
      >>> poly2 = ((0,0),(10,-5),(-10,-5))
      >>> s.addcomponent(poly2, "blue", "red")

3. Füge nun die Shape zur Formenliste des Screens hinzu und verwende
   sie:

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

Bemerkung:

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


Screen methods and functions
----------------------------

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


Fenstersteuerung
~~~~~~~~~~~~~~~~

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

   Gib die Hintergrundfarbe des TurtleScreen zurück oder setze sie.

   Vier Eingabeformate sind erlaubt:

   "bgcolor()"
      Gib die aktuelle Hintergrundfarbe als Farbangabe-String oder als
      Tupel zurück (siehe Beispiel). Kann als Eingabe für einen
      weiteren color/pencolor/fillcolor/bgcolor-Aufruf verwendet
      werden.

   "bgcolor(colorstring)"
      Gib die aktuelle Hintergrundfarbe als Farbangabe-String oder als
      Tupel zurück (siehe Beispiel). Kann als Eingabe für einen
      weiteren color/pencolor/fillcolor/bgcolor-Aufruf verwendet
      werden.

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

   "bgcolor(r, g, b)"
      Setze die Hintergrundfarbe auf die durch *r*, *g* und *b*
      dargestellte RGB-Farbe. Jeder der Werte *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** -- a string, name of a gif-file or ""nopic"", or
      "None"

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

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

turtle.clear()

   Bemerkung:

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

turtle.clearscreen()

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

turtle.reset()

   Bemerkung:

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

turtle.resetscreen()

   Setze alle Turtles auf dem Screen auf ihren Ausgangszustand zurück.

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

   Parameter:
      * **canvwidth** -- positive Ganzzahl, neue Breite der
        Zeichenfläche in Pixeln

      * **canvheight** -- positive Ganzzahl, neue Höhe der
        Zeichenfläche in Pixeln

      * **bg** -- Farbstring oder Farb-Tupel, neue Hintergrundfarbe

   Werden keine Argumente angegeben, wird das aktuelle (canvaswidth,
   canvasheight) zurückgegeben. Andernfalls wird die Zeichenfläche,
   auf der die Turtles zeichnen, in der Größe verändert. Das
   Zeichenfenster wird dabei nicht verändert. Um verborgene Teile der
   Zeichenfläche zu betrachten, verwende die Bildlaufleisten. Mit
   dieser Methode können Teile einer Zeichnung sichtbar gemacht
   werden, die zuvor außerhalb der Zeichenfläche lagen.

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

   e.g. to search for an erroneously escaped turtle ;-)

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

   Parameter:
      * **llx** -- eine Zahl, x-Koordinate der unteren linken Ecke der
        Zeichenfläche

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

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

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

   Richte ein benutzerdefiniertes Koordinatensystem ein und wechsle
   bei Bedarf in den Modus "world". Dies führt ein "screen.reset()"
   aus. Ist der Modus "world" bereits aktiv, werden alle Zeichnungen
   entsprechend den neuen Koordinaten neu gezeichnet.

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

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


Animationskontrolle
~~~~~~~~~~~~~~~~~~~

turtle.delay(delay=None)

   Parameter:
      **delay** -- positive Ganzzahl

   Setze oder gib die Zeichen-*delay* in Millisekunden zurück. (Dies
   ist ungefähr das Zeitintervall zwischen zwei aufeinanderfolgenden
   Aktualisierungen der Zeichenfläche.) Je länger die Zeichen-delay,
   desto langsamer die Animation.

   Optionales Argument:

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

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

   Parameter:
      * **n** -- nichtnegative Ganzzahl

      * **delay** -- nichtnegative Ganzzahl

   Schalte die Turtle-Animation ein/aus und setze die Verzögerung für
   Zeichnungsaktualisierungen. Wird *n* angegeben, wird nur jede n-te
   reguläre Bildschirmaktualisierung tatsächlich durchgeführt. (Kann
   verwendet werden, um das Zeichnen komplexer Grafiken zu
   beschleunigen.) Wird ohne Argumente aufgerufen, wird der aktuell
   gespeicherte Wert von n zurückgegeben. Das zweite Argument setzt
   den Verzögerungswert (siehe "delay()").

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

turtle.update()

   Führe eine TurtleScreen-Aktualisierung durch. Zu verwenden, wenn
   tracer ausgeschaltet ist.

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


Screen-Events verwenden
~~~~~~~~~~~~~~~~~~~~~~~

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

   Setze den Fokus auf TurtleScreen (um Tastatur-Ereignisse zu
   erfassen). Dummy-Argumente werden bereitgestellt, um "listen()" an
   die onclick-Methode übergeben zu können.

turtle.onkey(fun, key)
turtle.onkeyrelease(fun, key)

   Parameter:
      * **fun** -- eine Funktion ohne Argumente oder "None"

      * **key** -- eine Zeichenkette: Taste (z.B. "a") oder
        Tastensymbol (z.B. "space")

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

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

turtle.onkeypress(fun, key=None)

   Parameter:
      * **fun** -- eine Funktion ohne Argumente oder "None"

      * **key** -- eine Zeichenkette: Taste (z.B. "a") oder
        Tastensymbol (z.B. "space")

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

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

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

   Parameter:
      * **fun** -- eine Funktion mit zwei Argumenten, die mit den
        Koordinaten des angeklickten Punkts auf der Zeichenfläche
        aufgerufen wird

      * **btn** -- Nummer der Maustaste, standardmäßig 1 (linke
        Maustaste)

      * **add** -- "True" oder "False" -- ist es "True", wird eine
        neue Bindung hinzugefügt, andernfalls ersetzt sie eine
        vorherige Bindung

   Binde *fun* an Mausklick-Ereignisse auf diesem Screen. Ist *fun*
   "None", werden bestehende Bindungen entfernt.

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

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

   Bemerkung:

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

turtle.ontimer(fun, t=0)

   Parameter:
      * **fun** -- eine Funktion ohne Argumente

      * **t** -- eine Zahl >= 0

   Installiere einen Timer, der *fun* nach *t* Millisekunden aufruft.

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

turtle.mainloop()
turtle.done()

   Startet die Ereignisschleife – ruft die mainloop-Funktion von
   Tkinter auf. Muss die letzte Anweisung in einem Turtle-
   Grafikprogramm sein. Darf *nicht* verwendet werden, wenn ein Skript
   innerhalb von IDLE im -n-Modus (Kein Subprozess) ausgeführt wird –
   für die interaktive Verwendung von Turtle-Grafik.

      >>> screen.mainloop()


Eingabemethoden
~~~~~~~~~~~~~~~

turtle.textinput(title, prompt)

   Parameter:
      * **title** -- Zeichenkette

      * **prompt** -- Zeichenkette

   Öffne ein Dialogfenster zur Eingabe einer Zeichenkette. Der
   Parameter title ist der Titel des Dialogfensters, prompt ist ein
   Text, der meist beschreibt, welche Information einzugeben ist. Gib
   die eingegebene Zeichenkette zurück. Wird der Dialog abgebrochen,
   wird "None" zurückgegeben.

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

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

   Parameter:
      * **title** -- Zeichenkette

      * **prompt** -- Zeichenkette

      * **default** -- Zahl (optional)

      * **minval** -- Zahl (optional)

      * **maxval** -- Zahl (optional)

   Öffne ein Dialogfenster zur Eingabe einer Zahl. title ist der Titel
   des Dialogfensters, prompt ist ein Text, der meist beschreibt,
   welche numerische Information einzugeben ist. default:
   Standardwert, minval: Mindestwert für die Eingabe, maxval:
   Höchstwert für die Eingabe. Die eingegebene Zahl muss im Bereich
   minval .. maxval liegen, falls diese angegeben sind. Ist das nicht
   der Fall, wird ein Hinweis ausgegeben und der Dialog bleibt zur
   Korrektur geöffnet. Gib die eingegebene Zahl zurück. Wird der
   Dialog abgebrochen, wird "None" zurückgegeben.

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


Einstellungen und spezielle Methoden
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

turtle.mode(mode=None)

   Parameter:
      **mode** -- eine der Zeichenketten "standard", "logo" oder
      "world"

   Setze den Turtle-Modus ("standard", "logo" oder "world") und führe
   ein Reset durch. Wird mode nicht angegeben, wird der aktuelle Modus
   zurückgegeben.

   Mode "standard" is compatible with old "turtle".  Mode "logo" is
   compatible with most Logo turtle graphics.  Mode "world" uses user-
   defined "world coordinates". **Attention**: in this mode angles
   appear distorted if "x/y" unit-ratio doesn't equal 1.

   +--------------+---------------------------+---------------------+
   | Modus        | Anfängliche Ausrichtung   | positive Winkel     |
   |              | der Turtle                |                     |
   |==============|===========================|=====================|
   | "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

   Gib den colormode zurück oder setze ihn auf 1.0 oder 255.
   Anschließend müssen die Werte *r*, *g*, *b* von Farb-Tripeln 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()

   Gib die Canvas dieses TurtleScreen zurück. Nützlich für Insider,
   die wissen, was mit einer Tkinter-Canvas anzufangen ist.

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

turtle.getshapes()

   Gib eine Liste der Namen aller aktuell verfügbaren Turtle-Formen
   zurück.

      >>> screen.getshapes()
      ['arrow', 'blank', 'circle', ..., 'turtle']

turtle.register_shape(name, shape=None)
turtle.addshape(name, shape=None)

   There are three different ways to call this function:

   1. *name* is the name of a gif-file and *shape* is "None": Install
      the corresponding image shape.

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

      Bemerkung:

        Bildformen drehen sich *nicht* mit, wenn die Turtle gedreht
        wird, sie zeigen also nicht die Ausrichtung der Turtle an!

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

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

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

   Füge eine Turtle-Form zur Formenliste des TurtleScreen hinzu. Nur
   so registrierte Formen können durch den Befehl "shape(shapename)"
   verwendet werden.

turtle.turtles()

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

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

turtle.window_height()

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

      >>> screen.window_height()
      480

turtle.window_width()

   Gib die Weite des Turtle-Fensters zurück.

      >>> screen.window_width()
      640


Screen-only methods
~~~~~~~~~~~~~~~~~~~

turtle.bye()

   Schließe das Turtle-Grafikfenster.

turtle.exitonclick()

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

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

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

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

   Parameter:
      * **width** -- bei einer Ganzzahl eine Größe in Pixeln, bei
        einer Gleitkommazahl ein Anteil des Bildschirms; Standard ist
        50 % des Bildschirms

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

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

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

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

turtle.title(titlestring)

   Parameter:
      **titlestring** -- eine Zeichenkette, die in der Titelleiste des
      Turtle-Grafikfensters angezeigt wird

   Setze den Titel des Turtle-Fensters auf *titlestring*.

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


Öffentliche Klassen
-------------------

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

   Parameter:
      **canvas** -- 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

   Unterklasse von TurtleScreen, mit vier hinzugefügten Methoden.

class turtle.ScrolledCanvas(master)

   Parameter:
      **master** -- ein Tkinter-Widget, das den ScrolledCanvas
      enthält, d. h. ein Tkinter-Canvas mit hinzugefügten
      Bildlaufleisten

   Wird von der Klasse Screen verwendet, die dadurch automatisch einen
   ScrolledCanvas als Spielfläche für die Turtles bereitstellt.

class turtle.Shape(type_, data)

   Parameter:
      **type_** -- eine der Zeichenketten "polygon", "image",
      "compound"

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

   +-------------+------------------------------------------------------------+
   | *type_*     | *data*                                                     |
   |=============|============================================================|
   | "polygon"   | ein Polygon-Tupel, d. h. ein Tupel aus Koordinatenpaaren   |
   +-------------+------------------------------------------------------------+
   | "image"     | ein Bild (in dieser Form nur intern verwendet!)            |
   +-------------+------------------------------------------------------------+
   | "compound"  | "None" (eine zusammengesetzte Form muss mit der Methode    |
   |             | "addcomponent()" erstellt werden)                          |
   +-------------+------------------------------------------------------------+

   addcomponent(poly, fill, outline=None)

      Parameter:
         * **poly** -- ein Polygon, d.h. ein Tupel aus Zahlenpaaren

         * **fill** -- eine Farbe, mit der das *poly* gefüllt wird

         * **outline** -- eine Farbe für den Umriss des poly (falls
           angegeben)

      Beispiel:

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

      Siehe Zusammengesetzte Formen.

class turtle.Vec2D(x, y)

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

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

   * "a + b" Vectoraddition

   * "a - b" Vectorsubtraction

   * "a * b" Skalarprodukt

   * "k * a" und "a * k" Multiplikation mit Skalar

   * "abs(a)" Absolutwert von a

   * "a.rotate(angle)" Rotation


Erklärungen
-----------

Das Modul "turtle" definiert die folgende Ausnahme:

exception turtle.TurtleGraphicsError

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

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


How-to guides
=============

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


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


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 eingebaute 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 eingebaute 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 eingebauten Formen sein, z. B.: arrow, turtle
  usw. Für weitere Informationen versuche "help(shape)".

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

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

* If you set e.g. "language = italian" the docstringdict
  "turtle_docstringdict_italian.py" will be loaded at import time (if
  present on the import path, e.g. in the same directory as "turtle").

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

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

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

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


Erklärung
=========

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

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

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

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

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

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


"turtledemo" --- Demo scripts
=============================

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

   python -m turtledemo

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

   python -m turtledemo.bytedesign

The "turtledemo" package directory contains:

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

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

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

Die Demo-Skripte sind:

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

Viel Spaß!
