turtle
— Tortue graphique¶
Code Source : Lib/turtle.py
Introduction¶
Turtle graphics is an implementation of the popular geometric drawing tools introduced in Logo, developed by Wally Feurzeig, Seymour Papert and Cynthia Solomon in 1967.
Get started¶
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.
In Python, turtle graphics provides a representation of a physical "turtle" (a little robot with a pen) that draws on a sheet of paper on the floor.
It's an effective and well-proven way for learners to encounter programming concepts and interaction with software, as it provides instant, visible feedback. It also provides convenient access to graphical output in general.
Turtle drawing was originally created as an educational tool, to be used by teachers in the classroom. For the programmer who needs to produce some graphical output it can be a way to do that without the overhead of introducing more complex or external libraries into their work.
Tutoriel¶
New users should start here. In this tutorial we'll explore some of the basics of turtle drawing.
Starting a turtle environment¶
In a Python shell, import all the objects of the turtle
module:
from turtle import *
If you run into a No module named '_tkinter'
error, you'll have to
install the Tk interface package
on your system.
Basic drawing¶
Send the turtle forward 100 steps:
forward(100)
You should see (most likely, in a new window on your display) a line drawn by the turtle, heading East. Change the direction of the turtle, so that it turns 120 degrees left (anti-clockwise):
left(120)
Let's continue by drawing a triangle:
forward(100)
left(120)
forward(100)
Notice how the turtle, represented by an arrow, points in different directions as you steer it.
Experiment with those commands, and also with backward()
and
right()
.
Réglage des stylos¶
Try changing the color - for example, color('blue')
- and
width of the line - for example, width(3)
- and then drawing again.
You can also move the turtle around without drawing, by lifting up the pen:
up()
before moving. To start drawing again, use down()
.
The turtle's position¶
Send your turtle back to its starting-point (useful if it has disappeared off-screen):
home()
The home position is at the center of the turtle's screen. If you ever need to know them, get the turtle's x-y coordinates with:
pos()
Home is at (0, 0)
.
And after a while, it will probably help to clear the window so we can start anew:
clearscreen()
Making algorithmic patterns¶
Using loops, it's possible to build up geometric patterns:
for steps in range(100):
for c in ('blue', 'red', 'green'):
color(c)
forward(steps)
right(30)
- which of course, are limited only by the imagination!
Let's draw the star shape at the top of this page. We want red lines, filled in with yellow:
color('red')
fillcolor('yellow')
Just as up()
and down()
determine whether lines will be drawn,
filling can be turned on and off:
begin_fill()
Next we'll create a loop:
while True:
forward(200)
left(170)
if abs(pos()) < 1:
break
abs(pos()) < 1
is a good way to know when the turtle is back at its
home position.
Finally, complete the filling:
end_fill()
(Note that filling only actually takes place when you give the
end_fill()
command.)
How to...¶
This section covers some typical turtle use-cases and approaches.
Get started as quickly as possible¶
One of the joys of turtle graphics is the immediate, visual feedback that's available from simple commands - it's an excellent way to introduce children to programming ideas, with a minimum of overhead (not just children, of course).
The turtle module makes this possible by exposing all its basic functionality
as functions, available with from turtle import *
. The turtle
graphics tutorial covers this approach.
It's worth noting that many of the turtle commands also have even more terse
equivalents, such as fd()
for forward()
. These are especially
useful when working with learners for whom typing is not a skill.
You'll need to have the
Tk interface package
installed on your system for turtle graphics to work. Be warned that this is not always straightforward, so check this in advance if you're planning to use turtle graphics with a learner.
Use the turtle
module namespace¶
Using from turtle import *
is convenient - but be warned that it imports a
rather large collection of objects, and if you're doing anything but turtle
graphics you run the risk of a name conflict (this becomes even more an issue
if you're using turtle graphics in a script where other modules might be
imported).
The solution is to use import turtle
- fd()
becomes
turtle.fd()
, width()
becomes turtle.width()
and so on. (If typing
"turtle" over and over again becomes tedious, use for example import turtle
as t
instead.)
Use turtle graphics in a script¶
It's recommended to use the turtle
module namespace as described
immediately above, for example:
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)
Another step is also required though - as soon as the script ends, Python will also close the turtle's window. Add:
t.mainloop()
to the end of the script. The script will now wait to be dismissed and will not exit until it is terminated, for example by closing the turtle graphics window.
Use object-oriented turtle graphics¶
Voir aussi
Other than for very basic introductory purposes, or for trying things out as quickly as possible, it's more usual and much more powerful to use the object-oriented approach to turtle graphics. For example, this allows multiple turtles on screen at once.
In this approach, the various turtle commands are methods of objects (mostly of
Turtle
objects). You can use the object-oriented approach in the shell,
but it would be more typical in a Python script.
The example above then becomes:
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()
Note the last line. t.screen
is an instance of the Screen
that a Turtle instance exists on; it's created automatically along with
the turtle.
The turtle's screen can be customised, for example:
t.screen.title('Object-oriented turtle demo')
t.screen.bgcolor("orange")
Turtle graphics reference¶
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.
Les méthodes du module Turtle¶
- Les mouvements dans le module Turtle
- Bouger et dessiner
- Connaître l'état de la tortue
- Paramétrage et mesure
- Réglage des stylos
- État des stylos
- Réglage des couleurs
- Remplissage
- Plus des réglages pour le dessin
- État de la tortue
- Visibilité
- Apparence
- Utilisation des événements
- Méthodes spéciales de la tortue
Méthodes de TurtleScreen/Screen¶
- Réglage de la fenêtre
- Réglage de l'animation
- Utilisation des événements concernant l'écran
- Paramétrages et méthodes spéciales
- Méthodes de saisie
- Méthodes spécifiques de Screen
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()
etradians()
). L'orientation de l'angle dépend du mode de la tortue, voirmode()
.>>> 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()
etradians()
). L'orientation de l'angle dépend du mode de la tortue, voirmode()
.>>> 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 deVec2D
(par exemple, tel que renvoyé parpos()
).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.teleport(x, y=None, *, fill_gap=False)¶
- Paramètres:
x -- un nombre ou
None
y -- un nombre ou
None
fill_gap -- a boolean
Move turtle to an absolute position. Unlike goto(x, y), a line will not be drawn. The turtle's orientation does not change. If currently filling, the polygon(s) teleported from will be filled after leaving, and filling will begin again after teleporting. This can be disabled with fill_gap=True, which makes the imaginary line traveled during teleporting act as a fill barrier like in goto(x, y).
>>> tp = turtle.pos() >>> tp (0.00,0.00) >>> turtle.teleport(60) >>> turtle.pos() (60.00,0.00) >>> turtle.teleport(y=10) >>> turtle.pos() (60.00,10.00) >>> turtle.teleport(20, 30) >>> turtle.pos() (20.00,30.00)
Ajouté dans la version 3.12.
- 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") >>> stamp_id = turtle.stamp() >>> 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): ... unused_stamp_id = turtle.stamp() ... turtle.fd(30) >>> 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 etFalse
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 (voircolormode()
).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 (voircolormode()
).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()
etfillcolor()
.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)
etfillcolor(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 estFalse
.>>> 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.isvisible()¶
Renvoie
True
si la tortue est visible, etFalse
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é parshapesize()
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.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
ouFalse
— siTrue
, 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
ouFalse
— siTrue
, 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
ouFalse
— siTrue
, 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 estNone
, 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 :
Créez un objet Shape vide de type "compound".
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")
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"
, ouNone
Définit 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 estNone
, 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 globaleclear
est une fonction différente dérivée de la méthode Turtleclear
.
- 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 globalereset
est une fonction différente dérivée de la méthode Turtlereset
.
- 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éfinit 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éfinit 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éfinit 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éthodelisten()
.)>>> 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
ouFalse
— siTrue
, 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éeturtle
:>>> 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 globaleonclick
est une autre fonction dérivée de la méthode Turtleonclick
.
- 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)
Pop up a dialog window for input of a number. title is the title of the dialog window, prompt is a text mostly describing what numerical information to input. default: default value, minval: minimum value for input, maxval: maximum value for input. The number input must be in the range minval .. maxval if these are given. If not, a hint is issued and the dialog remains open for correction. Return the number input. If the dialog is canceled, return
None
.>>> screen.numinput("Poker", "Your stakes:", 1000, minval=10, maxval=10000)
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 dex/y
n'est pas 1.Mode
Orientation initiale de la tortue
angles positifs
"standard"
vers la droite (vers l'Est)
dans le sens inverse des aiguilles d'une montre
"logo"
vers le haut (vers le Nord)
dans le sens des 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éfinit à 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 :
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 !
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)))
name is an arbitrary string and shape is a (compound)
Shape
object: Install the corresponding compound shape.
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
dansturtle.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 horizontalementstarty -- 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éfinit le titre de la fenêtre de la tortue comme titlestring.
>>> screen.title("Welcome to the turtle zoo!")
Classes publiques¶
- class turtle.RawTurtle(canvas)¶
- class turtle.RawPen(canvas)¶
- Paramètres:
canvas -- a
tkinter.Canvas
, aScrolledCanvas
or aTurtleScreen
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 -- a
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éthodeaddcomponent()
)- 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 vecteursa - b
soustraction de deux vecteursa * b
produit scalairek * a
eta * k
multiplication avec un scalaireabs(a)
valeur absolue de aa.rotate(angle)
rotation
Explication¶
A turtle object draws on a screen object, and there a number of key classes in the turtle object-oriented interface that can be used to create them and relate them to each other.
A Turtle
instance will automatically create a Screen
instance if one is not already present.
Turtle
is a subclass of RawTurtle
, which doesn't automatically
create a drawing surface - a canvas will need to be provided or created for
it. The canvas can be a tkinter.Canvas
, ScrolledCanvas
or TurtleScreen
.
TurtleScreen
is the basic drawing surface for a
turtle. Screen
is a subclass of TurtleScreen
, and
includes some additional methods for managing its
appearance (including size and title) and behaviour. TurtleScreen
's
constructor needs a tkinter.Canvas
or a
ScrolledCanvas
as an argument.
The functional interface for turtle graphics uses the various methods of
Turtle
and TurtleScreen
/Screen
. Behind the scenes, a screen
object is automatically created whenever a function derived from a Screen
method is called. Similarly, a turtle object is automatically created
whenever any of the functions derived from a Turtle method is called.
To use multiple turtles on a screen, the object-oriented interface must be used.
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
.If you set e.g.
language = italian
the docstringdictturtle_docstringdict_italian.py
will be loaded at import time (if present on the import path, e.g. in the same directory asturtle
).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: Set this to
True
if you regularly work with IDLE and its-n
switch ("no subprocess"). This will preventexitonclick()
to enter the mainloop.
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 graphique classique |
|
chaos |
graphiques dynamiques de 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 |
world coordinates |
clock |
horloge analogique indiquant l'heure de votre ordinateur |
tortues sous forme des aiguilles d'horloge, sur minuterie |
colormixer (mélangeur de couleurs) |
des expériences en rouge, vert, bleu |
|
forest (forêt) |
3 arbres tracés par un parcours en largeur |
randomization (répartition aléatoire) |
fractalcurves |
Courbes de Hilbert et de Koch |
récursivité |
lindenmayer |
ethnomathématiques (kolams indiens) |
L-Système |
minimal_hanoi |
Tours de Hanoï |
Des tortues rectangulaires à la place des disques (shape, shapesize) |
nim |
jouez au classique jeu de nim avec trois piles de bâtons contre l'ordinateur. |
tortues en tant que bâtons de nim, géré par des événements (clavier et souris) |
paint (peinture) |
programme de dessin extra minimaliste |
|
peace (paix) |
basique |
tortue : apparence et animation |
penrose |
tuiles apériodiques avec cerfs-volants et fléchettes |
|
planet_and_moon (planète et lune) |
simulation d'un système gravitationnel |
formes composées, |
rosette |
un motif issu de l'article de wikipedia sur la tortue graphique |
|
round_dance |
tortues dansantes tournant par paires en sens inverse |
formes composées, clones de la forme (shapesize), rotation, get_shapepoly, update |
sorting_animate |
démonstration visuelle des différentes méthodes de classement |
alignement simple, répartition aléatoire |
tree (arbre) |
un arbre (tracé) par un parcours en largeur (à l’aide de générateurs) |
|
two_canvases (deux toiles) |
design simple |
tortues sur deux canevas |
yinyang |
un autre exemple élémentaire |
Amusez-vous !
Modifications depuis Python 2.6¶
The methods
Turtle.tracer
,Turtle.window_width
andTurtle.window_height
have been eliminated. Methods with these names and functionality are now available only as methods ofScreen
. The functions derived from these remain available. (In fact already in Python 2.6 these methods were merely duplications of the correspondingTurtleScreen
/Screen
methods.)The method
Turtle.fill()
has been eliminated. The behaviour ofbegin_fill()
andend_fill()
have changed slightly: now every filling process must be completed with anend_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 afill()
call without arguments in Python 2.6.
Modifications depuis Python 3.0¶
The
Turtle
methodsshearfactor()
,shapetransform()
andget_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.The
Screen
methodonkeypress()
has been added as a complement toonkey()
. 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 standalonemainloop()
function when working withScreen
andTurtle
objects.Two input methods have been added:
Screen.textinput
andScreen.numinput
. These pop up input dialogs and return strings and numbers respectively.Deux exemples de scripts
tdemo_nim.py
ettdemo_round_dance.py
ont été ajoutés au répertoireLib/turtledemo
.