"turtle" — Tortue graphique
***************************

**Code Source :** Lib/turtle.py

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


Introduction
============

Une tortue graphique est une manière bien connue et intuitive pour
initier les enfants au monde de la programmation. Un tel module
faisait partie initialement du langage de programmation Logo créé par
*Wally Feurzig* et *Seymout Papert* en 1967.

Imaginez un robot sous forme de tortue partant au centre (0, 0) d'un
plan cartésien x-y. Après un "import turtle", exécutez la commande
"turtle.forward(15)" et la tortue se déplace (sur l'écran) de 15
pixels en face d'elle, en dessinant une ligne.


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

La tortue permet de dessiner des formes complexes en utilisant un
programme qui répète des actions élémentaires.

[image]

   from turtle import *
   color('red', 'yellow')
   begin_fill()
   while True:
       forward(200)
       left(170)
       if abs(pos()) < 1:
           break
   end_fill()
   done()

On peut donc facilement construire des formes et images à partir de
commandes simples.

Le module "turtle" est une version étendue du module homonyme
appartenant à la distribution standard de Python jusqu'à la version
2.5.

Cette bibliothèque essaye de garder les avantages de l'ancien module
et d'être (presque) 100 % compatible avec celui-ci. Cela permet à
l'apprenti développeur d'utiliser toutes les commandes, classes et
méthodes de façon interactive pendant qu'il utilise le module depuis
*IDLE* lancé avec l'option "-n".

*Turtle* permet d'utiliser des primitives graphiques en utilisant un
style de programmation orienté objet ou procédural. Du fait qu'il
utilise la bibliothèque graphique "tkinter", *Turtle* a besoin d'une
version de python implémentant *Tk*.

L'interface orientée objet utilise essentiellement deux + deux classes
:

1. La classe "TurtleScreen" définit une fenêtre graphique utilisé
   comme un terrain de jeu pour les dessins de la tortue. Le
   constructeur de cette classe a besoin d'un "tkinter.Canvas" ou
   "ScrolledCanvas" comme argument. Cette classe doit être utilisée
   seulement si "turtle" fait partie intégrante d'une autre
   application.

   La fonction "Screen()" renvoie un singleton d'une sous-classe de
   "TurtleScreen". Elle doit être utilisée quand le module "turtle"
   est utilisé de façon autonome pour dessiner. Le singleton renvoyé
   ne peut hériter de sa classe.

   Toutes les méthodes de *TurtleScreen*/*Screen* existent également
   sous la forme de fonctions, c'est-à-dire que ces dernières peuvent
   être utilisées dans un style procédural.

2. La classe "RawTurtle" (alias "RawPen") définit des objets *Turtle*
   qui peuvent dessiner sur la classe "TurtleScreen". Son constructeur
   prend en paramètre un *Canvas*, un *ScrolledCanvas* ou un
   *TurtleScreen* permettant à l'objet *RawTurtle* de savoir où
   écrire.

   La sous-classe "Turtle" (alias: "Pen"), dérivée de *RawTurtle*,
   dessine sur l'instance "Screen" qui est créée automatiquement si
   elle n'est pas déjà présente.

   Toutes les méthodes de *RawTurtle*/*Turtle* existent également sous
   la forme de fonctions, c'est-à-dire que ces dernières pourront être
   utilisées en style procédural.

L'interface procédurale met à disposition des fonctions équivalentes à
celles des méthodes des classes "Screen" et "Turtle". Le nom d'une
fonction est le même que la méthode équivalente. Un objet *Screen* est
créé automatiquement dès qu'une fonction dérivée d'une méthode
*Screen* est appelée. Un objet *Turtle* (sans nom) est créé
automatiquement dès qu'une fonction dérivée d'une méthode *Turtle* est
appelée.

Afin de pouvoir utiliser plusieurs tortues simultanément sur l'écran,
vous devez utiliser l'interface orientée-objet.

Note:

  La liste des paramètres des fonctions est donnée dans cette
  documentation. Les méthodes ont, évidemment, le paramètre *self*
  comme premier argument, mais ce dernier n'est pas indiqué ici.


Résumé des méthodes de *Turtle* et *Screen* disponibles
=======================================================


Les méthodes du module *Turtle*
-------------------------------

Les mouvements dans le module *Turtle*
   Bouger et dessiner
         "forward()" | "fd()"
         "backward()" | "bk()" | "back()"
         "right()" | "rt()"
         "left()" | "lt()"
         "goto()" | "setpos()" | "setposition()"
         "setx()"
         "sety()"
         "setheading()" | "seth()"
         "home()"
         "circle()"
         "dot()"
         "stamp()"
         "clearstamp()"
         "clearstamps()"
         "undo()"
         "speed()"

   Connaître l'état de la tortue
         "position()" | "pos()"
         "towards()"
         "xcor()"
         "ycor()"
         "heading()"
         "distance()"

   Paramétrage et mesure
         "degrees()"
         "radians()"

Réglage des stylos
   État des stylos
         "pendown()" | "pd()" | "down()"
         "penup()" | "pu()" | "up()"
         "pensize()" | "width()"
         "pen()"
         "isdown()"

   Réglage des couleurs
         "color()"
         "pencolor()"
         "fillcolor()"

   Remplissage
         "filling()"
         "begin_fill()"
         "end_fill()"

   Plus des réglages pour le dessin
         "reset()"
         "clear()"
         "write()"

État de la tortue
   Visibilité
         "showturtle()" | "st()"
         "hideturtle()" | "ht()"
         "isvisible()"

   Apparence
         "shape()"
         "resizemode()"
         "shapesize()" | "turtlesize()"
         "shearfactor()"
         "settiltangle()"
         "tiltangle()"
         "tilt()"
         "shapetransform()"
         "get_shapepoly()"

Utilisation des événements
      "onclick()"
      "onrelease()"
      "ondrag()"

Méthodes spéciales de la tortue
      "begin_poly()"
      "end_poly()"
      "get_poly()"
      "clone()"
      "getturtle()" | "getpen()"
      "getscreen()"
      "setundobuffer()"
      "undobufferentries()"


Méthodes de *TurtleScreen*/*Screen*
-----------------------------------

Réglage de la fenêtre
      "bgcolor()"
      "bgpic()"
      "clearscreen()"
      "resetscreen()"
      "screensize()"
      "setworldcoordinates()"

Réglage de l'animation
      "delay()"
      "tracer()"
      "update()"

Utilisation des événements concernant l'écran
      "listen()"
      "onkey()" | "onkeyrelease()"
      "onkeypress()"
      "onclick()" | "onscreenclick()"
      "ontimer()"
      "mainloop()" | "done()"

Paramétrages et méthodes spéciales
      "mode()"
      "colormode()"
      "getcanvas()"
      "getshapes()"
      "register_shape()" | "addshape()"
      "turtles()"
      "window_height()"
      "window_width()"

Méthodes de saisie
      "textinput()"
      "numinput()"

Méthodes spécifiques de *Screen*
      "bye()"
      "exitonclick()"
      "setup()"
      "title()"


Méthodes de *RawTurtle*/*Turtle* et leurs fonctions correspondantes
===================================================================

La plupart des exemples de cette section se réfèrent à une instance de
*Turtle* appelée "turtle".


Les mouvements dans le module *Turtle*
--------------------------------------

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

   Paramètres:
      **distance** -- un nombre (entier ou flottant)

   Avance la tortue de la *distance* spécifiée, dans la direction où
   elle se dirige.

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

   Paramètres:
      **distance** -- un nombre

   Déplace la tortue de *distance* vers l'arrière (dans le sens opposé
   à celui vers lequel elle pointe). Ne change pas le cap de la
   tortue.

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

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

   Paramètres:
      **angle** -- un nombre (entier ou flottant)

   Tourne la tortue à droite de *angle* unités (les unités sont par
   défaut des degrés, mais peuvent être définies via les fonctions
   "degrees()" et "radians()"). L'orientation de l'angle dépend du
   mode de la tortue, voir "mode()".

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

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

   Paramètres:
      **angle** -- un nombre (entier ou flottant)

   Tourne la tortue à gauche d'une valeur de *angle* unités (les
   unités sont par défaut des degrés, mais peuvent être définies via
   les fonctions "degrees()" et "radians()"). L'orientation de l'angle
   dépend du mode de la tortue, voir "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)

   Paramètres:
      * **x** -- un nombre ou une paire / un vecteur de nombres

      * **y** -- un nombre ou "None"

   Si *y* est "None", *x* doit être une paire de coordonnées, ou bien
   une instance de "Vec2D" (par exemple, tel que renvoyé par "pos()").

   Déplace la tortue vers une position absolue. Si le stylo est en
   bas, trace une ligne. Ne change pas l'orientation de la tortue.

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

turtle.setx(x)

   Paramètres:
      **x** -- un nombre (entier ou flottant)

   Définit la première coordonnée de la tortue à *x*, en laissant la
   deuxième coordonnée inchangée.

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

turtle.sety(y)

   Paramètres:
      **y** -- un nombre (entier ou flottant)

   Définit la deuxième coordonnée de la tortue à *y*, en laissant la
   première coordonnée inchangée.

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

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

   Paramètres:
      **to_angle** -- un nombre (entier ou flottant)

   Règle l'orientation de la tortue à la valeur "to_angle". Voici
   quelques orientations courantes en degrés :

   +---------------------+----------------------+
   | mode standard       | mode logo            |
   |=====================|======================|
   | 0 – Est             | 0 – Nord             |
   +---------------------+----------------------+
   | 90 – Nord           | 90 – Est             |
   +---------------------+----------------------+
   | 180 – Ouest         | 180 – Sud            |
   +---------------------+----------------------+
   | 270 – Sud           | 270 – Ouest          |
   +---------------------+----------------------+

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

turtle.home()

   Déplace la tortue à l'origine — coordonnées (0,0) — et l'oriente à
   son cap initial (qui dépend du mode, voir "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)

   Paramètres:
      * **radius** -- un nombre

      * **extent** -- un nombre (ou "None")

      * **steps** -- un entier (ou "None")

   Dessine un cercle de rayon *radius*. Le centre se trouve à une
   distance de *radius* à gauche de la tortue ; l'angle *extent*
   détermine quelle partie du cercle est dessinée. Si *extent* n'est
   pas fourni, dessine le cercle en entier. Si *extent* ne correspond
   pas à un cercle entier, la position actuelle du stylo est donnée
   par l'un des points d'extrémité de l'arc de cercle. Si la valeur de
   *radius* est positive, dessine l'arc de cercle dans le sens inverse
   des aiguilles d'une montre, sinon le dessine dans le sens des
   aiguilles d'une montre. Enfin, la direction de la tortue peut être
   modifiée en réglant la valeur de *extent*.

   Comme le cercle est approximé par un polygone régulier inscrit,
   *steps* détermine le nombre de pas à utiliser. Si cette valeur
   n'est pas donnée, elle sera calculée automatiquement. Elle peut
   être utilisée pour dessiner des polygones réguliers.

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

turtle.dot(size=None, *color)

   Paramètres:
      * **size** -- un entier supérieur ou égal à 1 (si fourni)

      * **color** -- une chaîne qui désigne une couleur ou un triplet
        de couleur numérique

   Dessine un point circulaire de diamètre *size*, de la couleur
   *color*. Si le paramètre *size* n'est pas indiqué, utilise la
   valeur maximum de la taille du stylo plus 4 et de la taille du
   stylo multiplié par 2.

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

   Tamponne une copie de la forme de la tortue sur le canevas à la
   position actuelle de la tortue. Renvoie un *stamp_id* pour ce
   tampon, qui peut être utilisé pour le supprimer en appelant
   "clearstamp(stamp_id)".

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

turtle.clearstamp(stampid)

   Paramètres:
      **stampid** -- un entier, doit être la valeur renvoyée par
      l'appel précédent de "stamp()"

   Supprime le tampon dont le *stampid* est donné.

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

   Paramètres:
      **n** -- un entier (ou "None")

   Supprime tous, les *n* premiers ou les *n* derniers tampons de la
   tortue. Si *n* est "None", supprime tous les tampons, si *n* > 0,
   supprime les *n* premiers tampons et si n < 0, supprime les *n*
   derniers tampons.

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

turtle.undo()

   Annule la ou les dernières (si répété) actions de la tortue. Le
   nombre d'annulations disponible est déterminé par la taille de la
   mémoire tampon d'annulations.

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

turtle.speed(speed=None)

   Paramètres:
      **speed** -- un nombre entier compris dans l’intervalle entre 0
      et 10 inclus, ou une chaîne de vitesse (voir ci-dessous)

   Règle la vitesse de la tortue à une valeur entière comprise entre 0
   et 10 inclus. Si aucun argument n'est donné, renvoie la vitesse
   actuelle.

   Si l'entrée est un nombre supérieur à 10 ou inférieur à 0,5, la
   vitesse est fixée à 0. Les chaînes de vitesse sont mises en
   correspondance avec les valeurs de vitesse comme suit :

   * ""fastest"" :  0

   * ""fast"" :  10

   * ""normal"" :  6

   * ""slow"" :  3

   * ""slowest"" :  1

   Les vitesses de 1 à 10 permettent une animation de plus en plus
   rapide du trait du dessin et de la rotation des tortues.

   Attention : *speed* = 0 signifie qu'il n'y a *aucune* animation.
   *forward*/*back* font sauter la tortue et, de même, *left*/*right*
   font tourner la tortue instantanément.

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


Connaître l'état de la tortue
-----------------------------

turtle.position()
turtle.pos()

   Renvoie la position actuelle de la tortue (x,y) (en tant qu'un
   vecteur "Vec2d").

      >>> turtle.pos()
      (440.00,-0.00)

turtle.towards(x, y=None)

   Paramètres:
      * **x** -- un nombre, ou une paire / un vecteur de nombres, ou
        une instance de tortue

      * **y** -- un nombre si *x* est un nombre, sinon "None"

   Renvoie l'angle entre l'orientation d'origine et la ligne formée de
   la position de la tortue à la position spécifiée par (x,y), le
   vecteur ou l'autre tortue. L'orientation d'origine dépend du mode —
   "standard"/"world" ou "logo".

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

turtle.xcor()

   Renvoie la coordonnée x de la tortue.

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

turtle.ycor()

   Renvoie la coordonnée y de la tortue.

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

turtle.heading()

   Renvoie le cap de la tortue (la valeur dépend du mode de la tortue,
   voir "mode()").

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

turtle.distance(x, y=None)

   Paramètres:
      * **x** -- un nombre, ou une paire / un vecteur de nombres, ou
        une instance de tortue

      * **y** -- un nombre si *x* est un nombre, sinon "None"

   Renvoie la distance entre la tortue et (x,y), le vecteur donné ou
   l'autre tortue donnée. La valeur est exprimée en unités de pas de
   tortue.

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


Paramètres de mesure
--------------------

turtle.degrees(fullcircle=360.0)

   Paramètres:
      **fullcircle** -- un nombre

   Définit les unités de mesure des angles, c.-à-d. fixe le nombre de
   « degrés » pour un cercle complet. La valeur par défaut est de 360
   degrés.

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

   Règle l'unité de mesure des angles sur radians. Équivalent à
   "degrees(2*math.pi)".

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


Réglage des stylos
------------------


État des stylos
~~~~~~~~~~~~~~~

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

   Baisse la pointe du stylo — dessine quand il se déplace.

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

   Lève la pointe du stylo  — pas de dessin quand il se déplace.

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

   Paramètres:
      **width** -- un nombre positif

   Règle l'épaisseur de la ligne à *width* ou la renvoie. Si
   *resizemode* est défini à "auto" et que *turtleshape* (la forme de
   la tortue) est un polygone, le polygone est dessiné avec cette
   épaisseur. Si aucun argument n'est passé, la taille actuelle du
   stylo (*pensize*) est renvoyée.

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

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

   Paramètres:
      * **pen** -- un dictionnaire avec certaines ou toutes les clés
        énumérées ci-dessous

      * **pendict** -- un ou plusieurs arguments par mots-clés avec
        les clés suivantes comme mots-clés

   Renvoie ou définit les attributs du stylo dans un ""pen-
   dictionary"" avec les paires clés / valeurs suivantes :

   * ""shown"" : "True" / "False"

   * ""pendown"" : "True" / "False"

   * ""pencolor"" : chaîne de caractères ou triplet désignant la
     couleur du stylo

   * ""fillcolor"" : chaîne de caractères ou triplet pour la couleur
     de remplissage

   * ""pensize"" : nombre positif

   * ""speed"" : nombre compris dans intervalle 0 et 10

   * ""resizemode"" : ""auto"", ""user"" ou ""noresize""

   * ""stretchfactor"" : (nombre positif, nombre positif)

   * ""outline"" : nombre positif

   * ""tilt"" : nombre

   Ce dictionnaire peut être utilisé comme argument pour un appel
   ultérieur à "pen()" pour restaurer l'ancien état du stylo. En
   outre, un ou plus de ces attributs peuvent est passés en tant
   qu'arguments nommés. Cela peut être utilisé pour définir plusieurs
   attributs du stylo en une instruction.

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

   Renvoie "True" si la pointe du stylo est en bas et "False" si elle
   est en haut.

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


Réglage des couleurs
~~~~~~~~~~~~~~~~~~~~

turtle.pencolor(*args)

   Renvoie ou règle la couleur du stylo.

   Quatre formats d'entrée sont autorisés :

   "pencolor()"
      Renvoie la couleur du stylo actuelle en tant que chaine de
      spécification de couleurs ou en tant qu'un *n*-uplet (voir
      l'exemple). Peut être utilisée comme entrée à un autre appel de
      *color*/*pencolor*/*fillcolor*.

   "pencolor(colorstring)"
      Définit la couleur du stylo à "colorstring", qui est une chaîne
      de spécification de couleur *Tk*, telle que ""red"", ""yellow"",
      ou ""#33cc8c"".

   "pencolor((r, g, b))"
      Définit la couleur du stylo à la couleur RGB représentée par le
      *n*-uplet de *r*, *g* et *b*. Chacun des *r*, *g* et *b* doit
      être dans l'intervalle "0..colormode", où *colormode* est vaut
      1.0 ou 255 (voir "colormode()").

   "pencolor(r, g, b)"
      Définit la couleur du stylo à la couleur RGB représentée par
      *r*, *g* et *b*. Chacun des *r*, *g* et *b* doit être dans
      l'intervalle "0..colormode".

   Si la forme de la tortue est un polygone, le contour de ce polygone
   est dessiné avec la nouvelle couleur du stylo.

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

turtle.fillcolor(*args)

   Renvoie ou règle la couleur de remplissage.

   Quatre formats d'entrée sont autorisés :

   "fillcolor()"
      Renvoie la couleur de remplissage actuelle (*fillcolor*) en tant
      que chaine de spécification, possiblement en format *n*-uplet
      (voir l'exemple). Peut être utilisée en entrée pour un autre
      appel de *color*/*pencolor*/*fillcolor*.

   "fillcolor(colorstring)"
      Définit la couleur de remplissage (*fillcolor*) à *colorstring*,
      qui est une chaine de spécification de couleur *Tk* comme par
      exemple ""red"", ""yellow"" ou ""#33cc8c"".

   "fillcolor((r, g, b))"
      Définit la couleur du remplissage (*fillcolor*) à la couleur RGB
      représentée par le *n*-uplet  *r*, *g*, *b*. Chacun des *r*, *g*
      et *b* doit être dans l'intervalle "0..colormode" où *colormode*
      vaut 1.0 ou 255 (voir "colormode()").

   "fillcolor(r, g, b)"
      Définit la couleur du remplissage(*fillcolor*) à la couleur RGB
      représentée par *r*, *g* et *b*. Chacun des *r*, *g* et *b* doit
      être dans l'intervalle "0..colormode".

   Si la forme de la tortue est un polygone, l'intérieur de ce
   polygone sera dessiné avec la nouvelle couleur de remplissage.

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

turtle.color(*args)

   Renvoie ou règle la couleur du stylo et la couleur de remplissage.

   Plusieurs formats d'entrée sont autorisés. Ils peuvent avoir de
   zéro jusqu'à trois arguments, employés comme suit :

   "color()"
      Renvoie la couleur du stylo actuelle et la couleur de
      remplissage actuelle sous forme de paire, soit de chaines de
      spécification de couleur, soit de *n*-uplets comme renvoyés par
      "pencolor()" et "fillcolor()".

   "color(colorstring)", "color((r,g,b))", "color(r,g,b)"
      Les formats d'entrée sont comme dans "pencolor()". Définit à la
      fois la couleur de remplissage et la couleur du stylo à la
      valeur passée.

   "color(colorstring1, colorstring2)", "color((r1,g1,b1),
   (r2,g2,b2))"
      Équivalent à "pencolor(colorstring1)" et
      "fillcolor(colorstring2)" et de manière analogue si un autre
      format d'entrée est utilisé.

   Si la forme de la tortue est un polygone, le contour et l'intérieur
   de ce polygone sont dessinés avec les nouvelles couleurs.

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

Voir aussi : la méthode "colormode()" de *Screen*.


Remplissage
~~~~~~~~~~~

turtle.filling()

   Renvoie l'état de remplissage ("True" signifie en train de faire un
   remplissage, "False" sinon).

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

turtle.begin_fill()

   À appeler juste avant de dessiner une forme à remplir.

turtle.end_fill()

   Remplit la forme dessinée après le dernier appel à "begin_fill()".

   Le remplissage correct des formes complexes (polygones qui se
   recoupent, plusieurs formes) dépend des primitives graphiques du
   système d’exploitation, du type et du nombre des chevauchements.
   Par exemple, l'étoile (*Turtle star* en anglais) ci-dessus peut
   être entièrement jaune ou comporter quelques régions blanches.

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


Plus des réglages pour le dessin
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

turtle.reset()

   Supprime les dessins de la tortue de l'écran, recentre la tortue et
   assigne les variables aux valeurs par défaut.

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

   Supprime les dessins de la tortue de l'écran. Ne déplace pas la
   tortue. L'état et la position de la tortue ainsi que les dessins
   des autres tortues ne sont pas affectés.

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

   Paramètres:
      * **arg** -- objet à écrire sur le *TurtleScreen*

      * **move** -- "True" / "False"

      * **align** -- l'une des chaînes de caractères suivantes :
        ""left"", ""center"" ou ""right""

      * **font** -- triplet (nom de police, taille de police, type de
        police)

   Écrit du texte - La représentation de la chaîne *arg* - à la
   position actuelle de la tortue conformément à *align* ("*left*",
   "*center*" ou "*right*") et en police donnée. Si *move* est "True",
   le stylo est déplacé vers le coin inférieur droit du texte. Par
   défaut, *move* est "False".

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


État de la tortue
-----------------


Visibilité
~~~~~~~~~~

turtle.hideturtle()
turtle.ht()

   Rend la tortue invisible. C'est recommandé lorsque vous êtes en
   train de faire un dessin complexe, vous observerez alors une
   accélération notable.

      >>> turtle.hideturtle()

turtle.showturtle()
turtle.st()

   Rend la tortue visible.

      >>> turtle.showturtle()

turtle.isvisible()

   Renvoie "True" si la tortue est visible, et "False" si elle est
   cachée.

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


Apparence
~~~~~~~~~

turtle.shape(name=None)

   Paramètres:
      **name** -- une chaîne de caractères qui correspond à un nom de
      forme valide

   La tortue prend la forme *name* donnée, ou, si *name* n'est pas
   donné, renvoie le nom de la forme actuelle. Le nom *name* donné
   doit exister dans le dictionnaire de formes de *TurtleScreen*.
   Initialement, il y a les polygones suivants : "*arrow*",
   "*turtle*", "*circle*", "*square*", "*triangle*", "*classic*". Pour
   en apprendre plus sur comment gérer les formes, voir la méthode de
   *Screen* "register_shape()".

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

turtle.resizemode(rmode=None)

   Paramètres:
      **rmode** -- l'une des chaînes suivantes : ""auto"", ""user"",
      ""noresize""

   Définit *resizemode* à l'une des valeurs suivantes : "*auto*",
   "*user*", "*noresize*". Si "*rmode*" n'est pas donné, renvoie le
   *resizemode* actuel. Les différents *resizemode* ont les effets
   suivants :

   * *"auto"* : adapte l'apparence de la tortue en fonction de la
     largeur du stylo (*value of pensize* en anglais).

   * *"user"* : adapte l'apparence de la tortue en fonction des
     valeurs du paramètre d'étirement et de la largeur des contours,
     déterminés par "shapesize()".

   * *"noresize"* : il n'y a pas de modification de l'apparence de la
     tortue.

   "resizemode("user")" est appelé par "shapesize()" quand utilisé
   sans arguments.

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

   Paramètres:
      * **stretch_wid** -- nombre positif

      * **stretch_len** -- nombre positif

      * **outline** -- nombre positif

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

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

turtle.shearfactor(shear=None)

   Paramètres:
      **shear** -- un nombre (facultatif)

   Définit ou renvoie le paramétrage de cisaillement actuel. Déforme
   la tortue en fonction du paramètre *shear* donné, qui est la
   tangente de l'angle de cisaillement. Ne change pas le sens de
   déplacement de la tortue. Si le paramètre *shear* n'est pas
   indiqué, renvoie la valeur actuelle du cisaillement, c.-à-d. la
   valeur de la tangente de l'angle de cisaillement, celui par rapport
   auquel les lignes parallèles à la direction de la tortue sont
   cisaillées.

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

turtle.tilt(angle)

   Paramètres:
      **angle** -- un nombre

   Tourne la forme de la tortue de *angle* depuis son angle
   d'inclinaison actuel, mais *ne change pas* le cap de la tortue
   (direction du mouvement).

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

turtle.settiltangle(angle)

   Paramètres:
      **angle** -- un nombre

   Tourne la forme de la tortue pour pointer dans la direction
   spécifiée par *angle*, indépendamment de son angle d'inclinaison
   actuel. *Ne change pas* le cap de la tortue (direction du
   mouvement).

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

   Obsolète depuis la version 3.1.

turtle.tiltangle(angle=None)

   Paramètres:
      **angle** -- un nombre (facultatif)

   Définit ou renvoie l'angle d'inclinaison actuel. Si l'angle est
   donné, la forme de la tortue est tournée pour pointer dans
   direction spécifiée par l'angle, indépendamment de son angle
   d'inclinaison actuel. *Ne change pas* le cap de la tortue
   (direction du mouvement). Si l'angle n'est pas donné, renvoie
   l'angle d'inclinaison actuel (L'angle entre l'orientation de la
   forme de la tortue et le cap de la tortue (sa direction de
   mouvement)).

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

   Paramètres:
      * **t11** -- un nombre (facultatif)

      * **t12** -- un nombre (facultatif)

      * **t21** -- un nombre (facultatif)

      * **t12** -- un nombre (facultatif)

   Définit ou renvoie la matrice de transformation actuelle de la
   forme de la tortue.

   Si aucun élément de la matrice n'est fourni, renvoie la matrice de
   transformation sous la forme d'un *n*-uplet à 4 éléments.
   Autrement, définit les éléments donnés et transforme la forme de la
   tortue conformément à la matrice dont la première ligne est t11,
   t12 et la deuxième ligne t21, t22. Le déterminant t11 * t22 - t12 *
   t21 ne doit pas être nul, sinon une erreur est levée. Cela modifie
   le facteur d'étirement, le facteur de cisaillement et l'angle
   d'inclinaison en fonction de la matrice donnée.

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

   Renvoie la forme actuelle du polygone en *n*-uplet de paires de
   coordonnées. Vous pouvez l'utiliser afin de définir une nouvelle
   forme ou en tant que composant pour une forme plus complexe.

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


Utilisation des événements
--------------------------

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

   Paramètres:
      * **fun** -- une fonction à deux arguments qui sera appelée avec
        les coordonnées du point cliqué sur le canevas

      * **btn** -- numéro du bouton de la souris, par défaut 1 (bouton
        de gauche)

      * **add** -- "True" ou "False" — si "True", un nouveau lien est
        ajouté, sinon il remplace un ancien lien

   Crée un lien vers *fun* pour les événements de clics de la souris
   sur cette tortue. Si *fun* est "None", les liens existants sont
   supprimés. Exemple pour la tortue anonyme, c'est-à-dire la manière
   procédurale :

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

   Paramètres:
      * **fun** -- une fonction à deux arguments qui sera appelée avec
        les coordonnées du point cliqué sur le canevas

      * **btn** -- numéro du bouton de la souris, par défaut 1 (bouton
        de gauche)

      * **add** -- "True" ou "False" — si "True", un nouveau lien est
        ajouté, sinon il remplace un ancien lien

   Crée un lien vers *fun* pour les événements de relâchement d'un
   clic de la souris sur cette tortue. Si *fun* est "None", les liens
   existants sont supprimés.

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

   Paramètres:
      * **fun** -- une fonction à deux arguments qui sera appelée avec
        les coordonnées du point cliqué sur le canevas

      * **btn** -- numéro du bouton de la souris, par défaut 1 (bouton
        de gauche)

      * **add** -- "True" ou "False" — si "True", un nouveau lien est
        ajouté, sinon il remplace un ancien lien

   Crée un lien vers *fun* pour les événements de mouvement de la
   souris sur cette tortue. Si *fun* est "None", les liens existants
   sont supprimés.

   Remarque : toutes les séquences d'événements de mouvement de la
   souris sur une tortue sont précédées par un événement de clic de la
   souris sur cette tortue.

      >>> turtle.ondrag(turtle.goto)

   Par la suite, un cliquer-glisser sur la tortue la fait se déplacer
   au travers de l'écran, produisant ainsi des dessins « à la main »
   (si le stylo est posé).


Méthodes spéciales de la tortue
-------------------------------

turtle.begin_poly()

   Démarre l'enregistrement des sommets d'un polygone. La position
   actuelle de la tortue est le premier sommet du polygone.

turtle.end_poly()

   Arrête l'enregistrement des sommets d'un polygone. La position
   actuelle de la tortue sera le dernier sommet du polygone. Il sera
   connecté au premier sommet.

turtle.get_poly()

   Renvoie le dernier polygone sauvegardé.

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

   Crée et renvoie un clone de la tortue avec les mêmes position, cap
   et propriétés.

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

turtle.getturtle()
turtle.getpen()

   Renvoie l'objet *Turtle* lui-même. Sa seule utilisation : comme
   fonction pour renvoyer la "tortue anonyme" :

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

turtle.getscreen()

   Renvoie l'objet "TurtleScreen" sur lequel la tortue dessine. Les
   méthodes de TurtleScreen peuvent être appelées pour cet objet.

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

turtle.setundobuffer(size)

   Paramètres:
      **size** -- un entier ou "None"

   Définit ou désactive la mémoire d'annulation. Si *size* est un
   entier, une mémoire d'annulation de la taille donnée est installée.
   *size* donne le nombre maximum d'actions de la tortue qui peuvent
   être annulées par la fonction/méthode "undo()". Si *size* est
   "None", la mémoire d'annulation est désactivée.

      >>> turtle.setundobuffer(42)

turtle.undobufferentries()

   Renvoie le nombre d'entrées dans la mémoire d'annulation.

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


Formes composées
----------------

Pour utiliser des formes de tortues combinées, qui sont composées de
polygones de différentes couleurs, vous devez utiliser la classe
utilitaire "Shape" explicitement comme décrit ci-dessous :

1. Créez un objet Shape vide de type "compound".

2. Add as many components to this object as desired, using the
   "addcomponent()" method.

   Par exemple :

      >>> 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. Maintenant ajoutez la *Shape* à la liste des formes de *Screen* et
   utilisez la :

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

Note:

  La classe "Shape" est utilisée en interne par la méthode
  "register_shape()" de différentes façons. Le développeur n'interagit
  avec la classe Shape *que* lorsqu'il utilise des formes composées
  comme montré ci-dessus !


Méthodes de TurtleScreen/Screen et leurs fonctions correspondantes
==================================================================

La plupart des exemples dans cette section font référence à une
instance de TurtleScreen appelée "screen".


Réglage de la fenêtre
---------------------

turtle.bgcolor(*args)

   Paramètres:
      **args** -- chaîne spécifiant une couleur ou trois nombres dans
      l'intervalle *0..colormode* ou *n*-uplet de ces trois nombres

   Définit ou renvoie la couleur de fond de l'écran de la tortue
   (*TurtleScreen* en anglais).

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

turtle.bgpic(picname=None)

   Paramètres:
      **picname** -- une chaîne de caractères, le nom d'un fichier
      *gif*, ou ""nopic"", ou "None"

   Défini l'image de fond ou renvoie l'image de fond actuelle. Si
   *picname* est un nom de fichier, cette image et mis en image de
   fond. Si *picname* est ""nopic"", l'image de fond sera supprimée si
   présente. SI *picname* est "None", le nom du fichier de l'image de
   fond actuelle est renvoyé. :

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

turtle.clear()

   Note:

     Cette méthode TurtleScreen est disponible en tant que fonction
     globale seulement sous le nom "clearscreen". La fonction globale
     "clear" est une fonction différente dérivée de la méthode Turtle
     "clear".

turtle.clearscreen()

   Supprime tous les dessins et toutes les tortues du TurtleScreen.
   Réinitialise le TurtleScreen maintenant vide à son état initial :
   fond blanc, pas d'image de fond, pas d'événement liés, et traçage
   activé.

turtle.reset()

   Note:

     Cette méthode TurtleScreen est disponible en tant que fonction
     globale seulement sous le nom "resetscreen". La fonction globale
     "reset" est une fonction différente dérivée de la méthode Turtle
     "reset".

turtle.resetscreen()

   Remet toutes les tortues à l'écran dans leur état initial.

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

   Paramètres:
      * **canvwidth** -- nombre entier positif, nouvelle largeur du
        canevas (zone sur laquelle se déplace la tortue), en pixels

      * **canvheight** -- nombre entier positif, nouvelle hauteur du
        canevas, en pixels

      * **bg** -- chaîne de caractères indiquant la couleur ou triplet
        de couleurs, nouvelle couleur de fond

   Si aucun arguments ne sont passés, renvoie l'actuel *(canvaswidth,
   canvasheight)*. Sinon, redimensionne le canevas sur lequel les
   tortues dessinent. Ne modifiez pas la fenêtre de dessin. Pour
   observer les parties cachées du canevas, utilisez les barres de
   défilement. Avec cette méthode, on peut rendre visible les parties
   d'un dessin qui étaient en dehors du canevas précédemment.

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

   par exemple, chercher une tortue échappée de manière erronée

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

   Paramètres:
      * **llx** -- un nombre, coordonnée x du coin inférieur gauche du
        canevas

      * **lly** -- un nombre, la coordonnée y du coin inférieur gauche
        du canevas

      * **urx** -- un nombre, la coordonnée x du coin supérieur droit
        du canevas

      * **ury** -- un nombre, la coordonnée y du coin supérieur droit
        du canevas

   Configure un système de coordonnées défini par l'utilisateur et
   bascule vers le mode "world" si nécessaire. Cela effectuera un
   "screen.reset()". Si le mode "world" est déjà actif, tous les
   dessins sont re-déssinés par rapport aux nouveaux coordonnées.

   **ATTENTION** : dans les systèmes de coordonnées définis par
   l'utilisateur, les angles peuvent apparaître déformés.

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


Réglage de l'animation
----------------------

turtle.delay(delay=None)

   Paramètres:
      **delay** -- entier positif

   Défini ou renvoie le délai (*delay*) de dessin en millisecondes.
   (Cet approximativement le temps passé entre deux mises à jour du
   canevas.) Plus le délai est long, plus l'animation sera lente.

   Argument facultatif :

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

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

   Paramètres:
      * **n** -- entier non-négatif

      * **delay** -- entier non-négatif

   Active/désactive les animations des tortues et défini le délai pour
   mettre à jour les dessins.Si *n* est passé, seulement les n-ièmes
   mises à jours régulières de l'écran seront vraiment effectuées.
   (Peut être utilisé pour accélérer le dessin de graphiques
   complexes.) Lorsqu'appelé sans arguments, renvoie la valeur
   actuelle de *n*. Le deuxième argument défini la valeur du délai
   (voir "delay()").

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

turtle.update()

   Effectue une mise à jour de *TurtleScreen*. À utiliser lorsque le
   traceur est désactivé.

Voir aussi la méthode "speed()" de *RawTurtle*/*Turtle*.


Utilisation des événements concernant l'écran
---------------------------------------------

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

   Donne le focus à *TurtleScreen* (afin de collecter les événements
   clés). Des arguments factices sont fournis afin de pouvoir passer
   "listen()" à la méthode *onclick*.

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

   Paramètres:
      * **fun** -- une fonction sans arguments ou "None"

      * **key** -- une chaîne : clé (par exemple "*a*") ou clé symbole
        (Par exemple "*space*")

   Lie *fun* à l'événement d'un relâchement d'une touche. Si *fun* est
   "None", les événements liés sont supprimés. Remarque : Pour pouvoir
   enregistrer les événements lié au touches, TurtleScreen doit avoir
   le *focus* (fenêtre en premier plan). (Voir la méthode "listen()".)

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

turtle.onkeypress(fun, key=None)

   Paramètres:
      * **fun** -- une fonction sans arguments ou "None"

      * **key** -- une chaîne : clé (par exemple "*a*") ou clé symbole
        (Par exemple "*space*")

   Lie *fun* à l'événement d'un pressement de touche si *key* (touche)
   est donné, ou n'importe quelle touche si aucune touche n'est
   passée. Remarque : Pour pouvoir enregistrer des événements liés au
   touches, TurtleScreen doit être en premier plan. (voir la méthode
   "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)

   Paramètres:
      * **fun** -- une fonction à deux arguments qui sera appelée avec
        les coordonnées du point cliqué sur le canevas

      * **btn** -- numéro du bouton de la souris, par défaut 1 (bouton
        de gauche)

      * **add** -- "True" ou "False" — si "True", un nouveau lien est
        ajouté, sinon il remplace un ancien lien

   Crée un lien vers *fun* pour les événements de clique de la souris
   sur cet écran. Si *fun* est "None", les liens existants sont
   supprimés.

   Exemple pour une instance de TurtleScreen nommée "screen" et une
   instance Turtle nommée "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

   Note:

     Cette méthode de TurtleScreen est disponible en tant que fonction
     globale seulement sous le nom de "onscreenclick". La fonction
     globale "onclick" est une autre fonction dérivée de la méthode
     Turtle "onclick".

turtle.ontimer(fun, t=0)

   Paramètres:
      * **fun** -- une fonction sans arguments

      * **t** -- un nombre supérieur ou égal à 0

   Installe un minuteur qui appelle *fun* après *t* millisecondes.

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

   Démarre la boucle d'événements - appelle la boucle principale de
   Tkinter. Doit être la dernière opération dan un programme graphique
   *turtle*. **Ne dois pas** être utilisé si un script est lancé
   depuis IDLE avec le mode "-n" (pas de sous processus) - pour une
   utilisation interactive des graphiques *turtle* :

      >>> screen.mainloop()


Méthodes de saisie
------------------

turtle.textinput(title, prompt)

   Paramètres:
      * **title** -- chaîne de caractères

      * **prompt** -- chaîne de caractères

   Fait apparaitre une fenêtre pour entrer une chaine de caractères.
   Le paramètre *title* est le titre de la fenêtre, *prompt* est le
   texte expliquant quelle information écrire. Renvoie l'entrée
   utilisateur sous forme de chaîne. Si le dialogue est annulé,
   renvoie "None". :

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

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

   Paramètres:
      * **title** -- chaîne de caractères

      * **prompt** -- chaîne de caractères

      * **default** -- un nombre (facultatif)

      * **minval** -- un nombre (facultatif)

      * **maxval** -- un nombre (facultatif)

   Fait apparaitre une fenêtre pour entrer un nombre. Le paramètre
   *title* est le titre de la fenêtre, *prompt* est le texte
   expliquant quelle information numérique écrire. *default* : Valeur
   par défaut, *minval* : valeur minimale d'entrée, *maxval* : Valeur
   maximale d'entrée. Le nombre entré doit être dans la gamme
   *minval..maxval* si ces valeurs sont données. Sinon, un indice
   apparait et le dialogue reste ouvert pour corriger le nombre.
   Renvoie l'entrée utilisateur sous forme de nombre. Si le dialogue
   est annulé, renvoie "None". :

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


Paramétrages et méthodes spéciales
----------------------------------

turtle.mode(mode=None)

   Paramètres:
      **mode** -- l'une des chaînes de caractères : ""standard"",
      ""logo"" ou ""world""

   Règle le mode de la tortue ("*standard*", "*logo*" ou "*world*") et
   la réinitialise. Si le mode n'est pas donné, le mode actuel est
   renvoyé.

   Le mode "*standard*" est compatible avec l'ancien "turtle". Le mode
   "*logo*" est compatible avec la plupart des graphiques *turtle*
   Logo. Le mode "*world*" utilise des "coordonnées monde" (*world
   coordinates*) définis par l'utilisateur. **Attention** : Dans ce
   mode, les angles apparaissent déformés si le ratio unitaire de
   "x/y" n'est pas 1.

   +--------------+---------------------------+---------------------+
   | Mode         | Orientation initiale de   | angles positifs     |
   |              | la tortue                 |                     |
   |==============|===========================|=====================|
   | "standard"   | vers la droite (vers      | dans le sens        |
   |              | l'Est)                    | inverse des         |
   |              |                           | aiguilles d'une     |
   |              |                           | montre              |
   +--------------+---------------------------+---------------------+
   | "logo"       | vers le haut (vers le     | dans le sens des    |
   |              | Nord)                     | aiguilles d'une     |
   |              |                           | montre              |
   +--------------+---------------------------+---------------------+

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

turtle.colormode(cmode=None)

   Paramètres:
      **cmode** -- l'une des valeurs suivantes : 1.0 ou 255

   Renvoie le mode de couleur (*colormode*) ou le défini à 1.0 ou 255.
   Les valeurs *r*, *g* et *b* doivent aussi être dans la gamme
   "0"..*cmode*.

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

turtle.getcanvas()

   Renvoie le canevas de ce TurtleScreen. Utile pour les initiés qui
   savent quoi faire avec un canevas Tkinter.

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

turtle.getshapes()

   Renvoie une liste de noms de toutes les formes actuellement
   disponibles pour les tortues.

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

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

   Il existe trois façons différentes d’appeler cette fonction :

   1. *name* est le nom d'un fichier *gif* et *shape* est "None" :
      Installe la forme d'image correspondante. :

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

      Note:

        Les formes d'images *ne tournent pas* lorsque la tortue
        tourne, donc elles n'indiquent pas le cap de la tortue !

   2. *name* est une chaîne de caractères arbitraire et *shape* est un
      *n*-uplet de paires de coordonnées : Installe le polygone
      correspondant.

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

   3. *name* est une chaîne de caractères arbitraire et *shape* est un
      objet "Shape" (composé) : Installe la forme composée
      correspondante.

   Ajoute une forme de tortue a la liste des formes du TurtleScreen.
   Seulement les formes enregistrées de cette façon peuvent être
   utilisée avec la commande "shape(shapename)".

turtle.turtles()

   Renvoie la liste des tortues présentes sur l'écran.

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

turtle.window_height()

   Renvoie la hauteur de la fenêtre de la tortue. :

      >>> screen.window_height()
      480

turtle.window_width()

   Renvoie la largeur de la fenêtre de la tortue. :

      >>> screen.window_width()
      640


Méthodes spécifiques à Screen, non héritées de TurtleScreen
-----------------------------------------------------------

turtle.bye()

   Éteins la fenêtre *turtlegraphics*.

turtle.exitonclick()

   Lie la méthode "bye()" à un clique de souris sur l'écran
   (*Screen*).

   Si la valeur de "*using_IDLE*" dans le dictionnaire de
   configuration est "False" (valeur par défaut), démarre aussi la
   boucle principale. Remarque : Si IDLE est lancé avec l'option "-n"
   (Pas de sous processus), Cette valeur devrait être définie à "True"
   dans "turtle.cfg". Dans ce cas, la boucle principale d'IDLE est
   active aussi pour le script du client.

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

   Définit la taille et la position de la fenêtre principale. Les
   valeurs par défaut des arguments sont stockées dans le dictionnaire
   de configuration et peuvent être modifiées via un fichier
   "turtle.cfg".

   Paramètres:
      * **width** -- s'il s'agit d'un nombre entier, une taille en
        pixels, s'il s'agit d'un nombre flottant, une fraction de
        l'écran ; la valeur par défaut est de 50 % de l'écran

      * **height** -- s'il s'agit d'un nombre entier, la hauteur en
        pixels, s'il s'agit d'un nombre flottant, une fraction de
        l'écran ; la valeur par défaut est 75 % de l'écran

      * **startx** -- s'il s'agit d'un nombre positif, position de
        départ en pixels à partir du bord gauche de l'écran, s'il
        s'agit d'un nombre négatif, position de départ en pixels à
        partir du bord droit, si c'est "None", centre la fenêtre
        horizontalement

      * **starty** -- si positif, la position de départ en pixels
        depuis le haut de l'écran. Si négatif, depuis de bas de
        l'écran. Si "None", Le centre de la fenêtre verticalement

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

   Paramètres:
      **titlestring** -- chaîne de caractères affichée dans la barre
      de titre de la fenêtre graphique de la tortue

   Défini le titre de la fenêtre de la tortue à *titlestring*.

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


Classes publiques
=================

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

   Paramètres:
      **canvas** -- un "tkinter.Canvas", un "ScrolledCanvas" ou un
      "TurtleScreen"

   Crée une tortue. Cette tortue à toutes les méthodes décrites ci-
   dessus comme "Méthode de Turtle/RawTurtle".

class turtle.Turtle

   Sous-classe de RawTurtle, à la même interface mais dessine sur un
   objet "screen" par défaut créé automatiquement lorsque nécessaire
   pour la première fois.

class turtle.TurtleScreen(cv)

   Paramètres:
      **cv** -- un "tkinter.Canvas"

   Provides screen oriented methods like "bgcolor()" etc. that are
   described above.

class turtle.Screen

   Sous-classess de TurtleScreen, avec quatre nouvelles méthodes.

class turtle.ScrolledCanvas(master)

   Paramètres:
      **master** -- certain modules Tkinter pour contenir le
      ScrolledCanvas, c'est à dire, un canevas Tkinter avec des barres
      de défilement ajoutées

   Utilisé par la classe Screen, qui fournit donc automatiquement un
   ScrolledCanvas comme terrain de jeu pour les tortues.

class turtle.Shape(type_, data)

   Paramètres:
      **type_** -- l'une des chaînes suivantes : ""polygon"",
      ""image"" ou ""compound""

   Formes de modélisation de la structure des données. La paire
   "(type_, data)" doit suivre cette spécification :

   +-------------+------------------------------------------------------------+
   | *type_*     | *données*                                                  |
   |=============|============================================================|
   | "polygon"   | un polygone *n*-uplet, c'est-à-dire un *n*-uplet constitué |
   |             | de paires (chaque paire définissant des coordonnées)       |
   +-------------+------------------------------------------------------------+
   | "image"     | une image (utilisée uniquement en interne sous ce format   |
   |             | !)                                                         |
   +-------------+------------------------------------------------------------+
   | "compound"  | "None" (une forme composée doit être construite en         |
   |             | utilisant la méthode "addcomponent()")                     |
   +-------------+------------------------------------------------------------+

   addcomponent(poly, fill, outline=None)

      Paramètres:
         * **poly** -- un polygone, c.-à-d. un *n*-uplet de paires de
           nombres

         * **fill** -- une couleur de remplissage pour *poly*

         * **outline** -- une couleur pour le contour du polygone (si
           elle est donnée)

      Exemple :

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

      Voir Formes composées.

class turtle.Vec2D(x, y)

   Une classe de vecteur bidimensionnel, utilisée en tant que classe
   auxiliaire pour implémenter les graphiques *turtle*. Peut être
   utile pour les programmes graphiques faits avec *turtle*. Dérivé
   des *n*-uplets, donc un vecteur est un *n*-uplet !

   Permet (pour les vecteurs *a*, *b* et le nombre *k*) :

   * "a + b" addition de vecteurs

   * "a - b" soustraction de deux vecteurs

   * "a * b" produit scalaire

   * "k * a" et "a * k" multiplication avec un scalaire

   * "abs(a)" valeur absolue de a

   * "a.rotate(angle)" rotation


Aide et configuration
=====================


Utilisation de l'aide
---------------------

Les méthodes publiques des classes *Screen* et *Turtle* sont largement
documentées dans les *docstrings*. Elles peuvent donc être utilisées
comme aide en ligne via les fonctions d'aide de Python :

* Lors de l'utilisation d'IDLE, des info-bulles apparaissent avec la
  signature et les premières lignes de *docstring* de la
  fonction/méthode appelée.

* L'appel de "help()" sur les méthodes ou fonctions affichera les
  *docstrings* :

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

* Les *docstrings* des fonctions qui sont dérivées des méthodes ont
  une forme modifiée :

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

Ces chaînes de documents modifiées sont créées automatiquement avec
les définitions de fonctions qui sont dérivées des méthodes au moment
de l'importation.


Traduction de chaînes de documents en différentes langues
---------------------------------------------------------

Il est utile de créer un dictionnaire dont les clés sont les noms des
méthodes et les valeurs sont les *docstrings* de méthodes publiques
des classes Screen et Turtle.

turtle.write_docstringdict(filename='turtle_docstringdict')

   Paramètres:
      **filename** -- une chaîne de caractères, utilisée en tant que
      nom de fichier

   Crée et écrit un dictionnaire de *docstrings* dans un script Python
   avec le nom donné. Cette fonction doit être appelée explicitement
   (elle n'est pas utilisée par les classes graphiques de *turtle*).
   Ce dictionnaire de *doctrings* sera écrit dans le script Python
   "*filename*.py". Il sert de modèle pour la traduction des
   *docstrings* dans différentes langues.

Si vous (ou vos étudiants) veulent utiliser "turtle" avec de l'aide en
ligne dans votre langue natale, vous devez traduire les *docstrings*
et sauvegarder les fichiers résultants en, par exemple,
"turtle_docstringdict_german.py".

Si vous avez une entrée appropriée dans votre fichier "turtle.cfg", ce
dictionnaire est lu au moment de l'importation et remplace la
*docstrings* originale en anglais par cette entrée.

Au moment de l'écriture de cette documentation, il n'existe seulement
que des *docstrings* en Allemand et Italien. (Merci de faire vos
demandes à glingl@aon.at.)


Comment configurer *Screen* et *Turtle*
---------------------------------------

La configuration par défaut imite l'apparence et le comportement de
l'ancien module *turtle* pour pouvoir maintenir la meilleure
compatibilité avec celui-ci.

Si vous voulez utiliser une configuration différente qui reflète mieux
les fonctionnalités de ce module ou qui correspond mieux à vos
besoins, par exemple pour un cours, vous pouvez préparer un ficher de
configuration "turtle.cfg" qui sera lu au moment de l'importation et
qui modifiera la configuration en utilisant les paramètres du fichier.

The built in configuration would correspond to the following
"turtle.cfg":

   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

Brève explication des entrées sélectionnées :

* The first four lines correspond to the arguments of the
  "Screen.setup" method.

* Line 5 and 6 correspond to the arguments of the method
  "Screen.screensize".

* *shape* peut être n'importe quelle forme native, par exemple
  *arrow*, *turtle* etc. Pour plus d'informations, essayez
  "help(shape)".

* If you want to use no fill color (i.e. make the turtle transparent),
  you have to write "fillcolor = """ (but all nonempty strings must
  not have quotes in the cfg file).

* Si vous voulez refléter l'état de la tortue, vous devez utiliser
  "resizemode = auto".

* Si vous définissez par exemple "language = italian", le dictionnaire
  de *docstrings* "turtle.docstringdict_italian.py" sera chargé au
  moment de l'importation (si présent dans les chemins d'importations,
  par exemple dans le même dossier que "turtle").

* Les entrées *exampleturtle* et *examplescreen* définissent les noms
  de ces objets tels qu'ils apparaissent dans les *docstrings*. La
  transformation des méthodes-*docstrings* vers fonction-*docstrings*
  supprimera ces noms des *docstrings*.

* *using_IDLE* : définissez ceci à "True" si vous travaillez
  régulièrement avec IDLE et son option "-n" (pas de sous processus).
  Cela évitera l'entrée de "exitonclick()" dans la boucle principale.

Il peut y avoir un "turtle.cfg" dans le dossier où se situe "turtle"
et un autre dans le dossier de travail courant. Ce dernier prendra le
dessus.

Le dossier "Lib/turtledemo" contient un fichier "turtle.cfg". Vous
pouvez le prendre comme exemple et voir ses effets lorsque vous lancez
les démos (il est préférable de ne pas le faire depuis la visionneuse
de démos).


"turtledemo" — Scripts de démonstration
=======================================

Le paquet "turtledemo" inclut un ensemble de scripts de démonstration.
Ces scripts peuvent être lancés et observés en utilisant la
visionneuse de démos comme suit :

   python -m turtledemo

Alternativement, vous pouvez lancer les scripts de démo
individuellement. Par exemple :

   python -m turtledemo.bytedesign

Le paquet "turtledemo" contient :

* Une visionneuse "__main__.py" qui peut être utilisée pour lire le
  code source de ces scripts et pour les faire tourner en même temps.

* Plusieurs script présentent les différentes fonctionnalités du
  module "turtle". Les exemples peuvent être consultés via le menu
  *Examples*. Ils peuvent aussi être lancés de manière autonome.

* Un fichier exemple "turtle.cfg" montrant comment rédiger de tels
  fichiers.

Les scripts de démonstration sont :

+------------------+--------------------------------+-------------------------+
| Nom              | Description                    | Caractéristiques        |
|==================|================================|=========================|
| *bytedesign*     | motif complexe de la tortue    | "tracer()", temps mort, |
|                  | graphique classique            | "update()"              |
+------------------+--------------------------------+-------------------------+
| chaos            | graphiques dynamiques de       | *world coordinates*     |
|                  | Verhulst, cela démontre que    |                         |
|                  | les calculs de l'ordinateur    |                         |
|                  | peuvent générer des résultats  |                         |
|                  | qui vont parfois à l'encontre  |                         |
|                  | du bon sens                    |                         |
+------------------+--------------------------------+-------------------------+
| *clock*          | horloge analogique indiquant   | tortues sous forme des  |
|                  | l'heure de votre ordinateur    | aiguilles d'horloge,    |
|                  |                                | sur minuterie           |
+------------------+--------------------------------+-------------------------+
| *colormixer*     | des expériences en rouge,      | "ondrag()"              |
| (mélangeur de    | vert, bleu                     |                         |
| couleurs)        |                                |                         |
+------------------+--------------------------------+-------------------------+
| *forest* (forêt) | 3 arbres tracés par un         | *randomization*         |
|                  | parcours en largeur            | (répartition aléatoire) |
+------------------+--------------------------------+-------------------------+
| *fractalcurves*  | Courbes de Hilbert et de Koch  | récursivité             |
+------------------+--------------------------------+-------------------------+
| *lindenmayer*    | ethnomathématiques (kolams     | *L-Système*             |
|                  | indiens)                       |                         |
+------------------+--------------------------------+-------------------------+
| *minimal_hanoi*  | Tours de Hanoï                 | Des tortues             |
|                  |                                | rectangulaires à la     |
|                  |                                | place des disques       |
|                  |                                | (*shape*, *shapesize*)  |
+------------------+--------------------------------+-------------------------+
| *nim*            | jouez au classique jeu de      | tortues en tant que     |
|                  | *nim* avec trois piles de      | bâtons de *nim*, géré   |
|                  | bâtons contre l'ordinateur.    | par des événements      |
|                  |                                | (clavier et souris)     |
+------------------+--------------------------------+-------------------------+
| *paint*          | programme de dessin extra      | "onclick()"             |
| (peinture)       | minimaliste                    |                         |
+------------------+--------------------------------+-------------------------+
| *peace* (paix)   | basique                        | tortue : apparence et   |
|                  |                                | animation               |
+------------------+--------------------------------+-------------------------+
| *penrose*        | tuiles apériodiques avec       | "stamp()"               |
|                  | cerfs-volants et fléchettes    |                         |
+------------------+--------------------------------+-------------------------+
| *planet_and_moo  | simulation d'un système        | formes composées,       |
| n* (planète et   | gravitationnel                 | "Vec2D"                 |
| lune)            |                                |                         |
+------------------+--------------------------------+-------------------------+
| rosette          | un motif issu de l'article de  | "clone()", "undo()"     |
|                  | *wikipedia* sur la tortue      |                         |
|                  | graphique                      |                         |
+------------------+--------------------------------+-------------------------+
| *round_dance*    | tortues dansantes tournant par | formes composées,       |
|                  | paires en sens inverse         | clones de la forme      |
|                  |                                | (*shapesize*),          |
|                  |                                | rotation,               |
|                  |                                | *get_shapepoly*,        |
|                  |                                | *update*                |
+------------------+--------------------------------+-------------------------+
| *sorting_animat  | démonstration visuelle des     | alignement simple,      |
| e*               | différentes méthodes de        | répartition aléatoire   |
|                  | classement                     |                         |
+------------------+--------------------------------+-------------------------+
| *tree* (arbre)   | un arbre (tracé) par un        | "clone()"               |
|                  | parcours en largeur (à l’aide  |                         |
|                  | de générateurs)                |                         |
+------------------+--------------------------------+-------------------------+
| *two_canvases*   | design simple                  | tortues sur deux        |
| (deux toiles)    |                                | canevas                 |
+------------------+--------------------------------+-------------------------+
| *yinyang*        | un autre exemple élémentaire   | "circle()"              |
+------------------+--------------------------------+-------------------------+

Amusez-vous !


Modifications depuis Python 2.6
===============================

* The methods "Turtle.tracer", "Turtle.window_width" and
  "Turtle.window_height" have been eliminated. Methods with these
  names and functionality are now available only as methods of
  "Screen". The functions derived from these remain available. (In
  fact already in Python 2.6 these methods were merely duplications of
  the corresponding "TurtleScreen"/"Screen" methods.)

* The method "Turtle.fill()" has been eliminated. The behaviour of
  "begin_fill()" and "end_fill()" have changed slightly: now every
  filling process must be completed with an "end_fill()" call.

* A method "Turtle.filling" has been added. It returns a boolean
  value: "True" if a filling process is under way, "False" otherwise.
  This behaviour corresponds to a "fill()" call without arguments in
  Python 2.6.


Modifications depuis Python 3.0
===============================

* The "Turtle" methods "shearfactor()", "shapetransform()" and
  "get_shapepoly()" have been added. Thus the full range of regular
  linear transforms is now available for transforming turtle shapes.
  "tiltangle()" has been enhanced in functionality: it now can be used
  to get or set the tilt angle. "settiltangle()" has been deprecated.

* The "Screen" method "onkeypress()" has been added as a complement to
  "onkey()". As the latter binds actions to the key release event, an
  alias: "onkeyrelease()" was also added for it.

* The method "Screen.mainloop" has been added, so there is no longer a
  need to use the standalone "mainloop()" function when working with
  "Screen" and "Turtle" objects.

* Two input methods have been added: "Screen.textinput" and
  "Screen.numinput". These pop up input dialogs and return strings and
  numbers respectively.

* Deux exemples de scripts "tdemo_nim.py" et "tdemo_round_dance.py"
  ont été ajoutés au répertoire "Lib/turtledemo".
