turtle Tortue graphique

(1)

Turtle star

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

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.

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éve- loppeur 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 ap- plication.

from turtle import * color('red', 'yellow') begin_fill()

while True:

forward(200) left(170)

if abs(pos()) < 1:

break end_fill() done()

Go 3.10.1

(2)

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 équiva- lente. 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 fonc- tion 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()

Go 3.10.1

(3)

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

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

Go 3.10.1

(4)

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

Go 3.10.1

(5)

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.back(distance) turtle.bk(distance)

>>> turtle.position() (0.00,0.00)

>>> turtle.forward(25)

>>> turtle.position() (25.00,0.00)

>>> turtle.forward(-75)

>>> turtle.position() (-50.00,0.00)

>>>

Go 3.10.1

(6)

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.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.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 de- gré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.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.

>>> turtle.position() (0.00,0.00)

>>> turtle.backward(30)

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

>>>

>>> turtle.heading()

22.0>>> turtle.right(45)

>>> turtle.heading() 337.0

>>>

22.0>>> turtle.left(45)

>>>

Go 3.10.1

(7)

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 in- changée.

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 in- changée.

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

dard mode logo

0 – Est 0 – Nord

90 – Nord 90 – Est 180 – Ouest 180 – Sud 270 – Sud 270 – Ouest >>> 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.position() (0.00,240.00)

>>> turtle.setx(10)

>>> turtle.position() (10.00,240.00)

>>>

>>> turtle.position() (0.00,40.00)

>>> turtle.sety(-10)

>>> turtle.position() (0.00,-10.00)

>>>

Go 3.10.1

(8)

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.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.dot(size=None, *color)

>>> turtle.setheading(90)

>>>

90.0>>> turtle.position()

(0.00,-10.00)

>>> turtle.home()

>>> turtle.position() (0.00,0.00)

>>>

>>> turtle.position() (0.00,0.00)

0.0>>> turtle.circle(50)

>>> turtle.position() (-0.00,0.00)

0.0>>> turtle.circle(120, 180) # draw a semicircle

>>> turtle.position() (0.00,240.00)

>>>

Go 3.10.1

(9)

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 nu- mé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.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.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.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.

>>> turtle.dot()

>>> turtle.fd(50); turtle.dot(20, "blue"); turtle.fd(50)

>>> turtle.position() (100.00,-0.00)

>>>

>>> turtle.color("blue")

>>> turtle.stamp()

11>>> turtle.fd(50)

>>>

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

>>>

>>> for i in range(8):

... turtle.stamp(); turtle.fd(30) 13

>>>

Go 3.10.1

(10)

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.

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 :

« le plus rapide » : 0

« rapide » : 10

« vitesse normale » : 6

« lent » : 3

« le plus lent » : 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.

1415 1617 1819

20>>> turtle.clearstamps(2)

>>> turtle.clearstamps(-2)

>>> turtle.clearstamps()

>>> for i in range(4):

... turtle.fd(50); turtle.lt(80)

...>>> for i in range(8):

... turtle.undo()

>>>

>>> turtle.speed()

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

>>> turtle.speed() 6

>>> turtle.speed(9)

>>> turtle.speed() 9

>>>

Go 3.10.1

(11)

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

Renvoie la coordonnée x de la tortue.

turtle.ycor()

Renvoie la coordonnée y de la tortue.

turtle.heading()

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

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

>>>

>>> turtle.goto(10, 10)

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

>>>

>>> turtle.left(50)

>>> turtle.pos() (64.28,76.60)

>>> print(round(turtle.xcor(), 5)) 64.27876

>>>

>>> print(turtle.pos()) (50.00,86.60)

>>> print(round(turtle.ycor(), 5)) 86.60254

>>>

Go 3.10.1

(12)

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.

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

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

Réglage des stylos État des stylos

>>> turtle.distance(30,40)

50.0>>> turtle.distance((30,40))

50.0>>> joe = Turtle()

>>> joe.forward(77)

>>> turtle.distance(joe) 77.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.degrees(360)

>>>

90.0>>> turtle.radians()

>>> turtle.heading() 1.5707963267948966

>>>

Go 3.10.1

(13)

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.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 sui- vantes 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.pensize()

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

>>>

>>> turtle.pen(fillcolor="black", pencolor="red", pensize=10) >>>

Go 3.10.1

(14)

turtle.isdown()

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

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.

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

>>> turtle.isdown() False

>>> turtle.pendown()

>>> turtle.isdown() True

>>>

Go 3.10.1

(15)

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écifica- tion, 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écifi- cation 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ù co- lormode 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.

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

Go 3.10.1

(16)

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 ren- voyé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 des- sinés avec les nouvelles couleurs.

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

À appeler juste avant de dessiner une forme à remplir.

turtle.end_fill()

>>> turtle.fillcolor() (255.0, 255.0, 255.0)

>>> turtle.color("red", "green") >>> turtle.color()

('red', 'green')

>>> color("#285078", "#a0c8f0") >>> color()

((40.0, 80.0, 120.0), (160.0, 200.0, 240.0))

>>> turtle.begin_fill() >>> if turtle.filling():

... turtle.pensize(5) ... else:

... turtle.pensize(3)

Go 3.10.1

(17)

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.

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

État de la tortue Visibilité

>>> turtle.color("black", "red")

>>> turtle.begin_fill()

>>> turtle.circle(80)

>>> turtle.end_fill()

>>>

>>> turtle.goto(0,-22)

>>> turtle.position() (0.00,-22.00)

>>> turtle.reset()

>>> turtle.position() (0.00,0.00)

>>>

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

>>> turtle.write((0,0), True)

>>>

Go 3.10.1

(18)

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.showturtle() turtle.st()

Rend la tortue visible.

turtle.isvisible()

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

Apparence

turtle.shape(name=None)

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

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.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 pen- size en anglais).

>>> turtle.hideturtle() >>>

>>> turtle.showturtle() >>>

>>> turtle.hideturtle()

>>> turtle.isvisible() False

>>> turtle.showturtle()

>>> turtle.isvisible() True

>>>

>>> turtle.shape() 'classic'

>>> turtle.shape("turtle")

>>> turtle.shape() 'turtle'

>>>

Go 3.10.1

(19)

"user" : adapte l'apparence de la tortue en fonction des valeurs du paramètre d'étire- ment 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.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

Renvoie ou définit les attributs x/y-stretchfactors* et/ou contour du stylo. Définit resize- mode à "user". Si et seulement si resizemode est à "user", la tortue sera affichée étirée en fonction de ses facteurs d'étirements (stretchfactors) : stretch_wid est le facteur d'éti- rement perpendiculaire à son orientation, stretch_len est le facteur d'étirement en direction de son orientation, outlline détermine la largeur de la bordure de la forme.

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

Paramètres: angle -- un nombre

>>> turtle.resizemode() 'noresize'

>>> turtle.resizemode("auto")

>>> turtle.resizemode() 'auto'

>>>

>>> 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.shape("circle") >>> turtle.shapesize(5,2) >>> turtle.shearfactor(0.5) >>> turtle.shearfactor() 0.5

Go 3.10.1

(20)

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.settiltangle(angle) Paramètres: angle -- un nombre

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

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

>>> turtle.shape("circle")

>>> turtle.shapesize(5,2)

>>> turtle.tilt(30)

>>> turtle.fd(50)

>>>

>>> turtle.settiltangle(45)

>>> turtle.fd(50)

>>> turtle.settiltangle(-45)

>>> turtle.fd(50)

>>>

>>> turtle.tiltangle() 45.0

>>>

Go 3.10.1

(21)

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

Utilisation des événements

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

Paramètres: fun -- une fonction à deux arguments qui sera appelée avec les coor- donné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 :

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

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

>>> turtle = Turtle()

>>> turtle.shape("square")

>>> turtle.shearfactor(-0.5)

>>> turtle.shapetransform() (4.0, -1.0, -0.0, 2.0)

>>>

>>> turtle.shape("square")

>>> turtle.shapetransform(4, -1, 0, 2)

>>> turtle.get_shapepoly()

((50, -20), (30, 20), (-50, 20), (-30, -20))

>>>

>>> def turn(x, y):

... left(180)

...>>> onclick(turn) # Now clicking into the turtle will turn it.

>>> onclick(None) # event-binding will be removed

>>>

Go 3.10.1

(22)

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.

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

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.

Par la suite, un cliquer-glisser sur la tortue la fait se déplacer au travers de l'écran, produi- sant 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é.

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

>>> turtle.onrelease(turtle.unglow) # releasing turns it to transp

>>>

>>> turtle.ondrag(turtle.goto) >>>

>>> turtle.begin_poly()

>>> turtle.fd(100)

>>> turtle.fd(30)

>>> turtle.fd(50)

>>> turtle.end_poly()

>>>

Go 3.10.1

(23)

turtle.clone()

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

turtle.getturtle() turtle.getpen()

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

"tortue anonyme" :

turtle.getscreen()

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

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

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

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 :

>>> p = turtle.get_poly()

>>> register_shape("myFavouriteShape", p)

>>> mick = Turtle()

>>> joe = mick.clone()

>>>

>>> pet = getturtle()

>>> pet.fd(50)

>>> pet

<turtle.Turtle object at 0x...>

>>>

>>> ts = turtle.getscreen()

>>> ts

<turtle._Screen object at 0x...>

>>> ts.bgcolor("pink")

>>>

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

>>> while undobufferentries():

... undo()

>>>

Go 3.10.1

(24)

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

2. Ajoutez autant de composants que désirés à cet objet, en utilisant la méthode addcomponent().

Par exemple :

3. Maintenant ajoutez la Shape à la liste des formes de Screen et utilisez la :

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 ap- pelé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).

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é. :

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

>>>

>>> register_shape("myshape", s)

>>> shape("myshape")

>>>

>>> screen.bgcolor("orange")

>>> screen.bgcolor() 'orange'

>>> screen.bgcolor("#800080")

>>> screen.bgcolor() (128.0, 0.0, 128.0)

>>>

Go 3.10.1

(25)

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.

par exemple, chercher une tortue échappée de manière erronée turtle.setworldcoordinates(llx, lly, urx, ury)

>>> screen.bgpic() 'nopic'

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

>>> screen.bgpic()

"landscape.gif"

>>>

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

>>> screen.screensize(2000,1500)

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

>>>

Go 3.10.1

(26)

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.

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 :

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 vrai- ment 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.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

>>>

>>> screen.delay()

10>>> screen.delay(5)

>>> screen.delay() 5

>>>

>>> screen.tracer(8, 25)

>>> dist = 2

>>> for i in range(200):

... fd(dist) ... rt(90)

>>>

Go 3.10.1

(27)

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

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

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

turtle.onscreenclick(fun, btn=1, add=None) ... dist += 2

>>> def f():

... fd(50) ... lt(60)

...>>> screen.onkey(f, "Up")

>>> screen.listen()

>>>

>>> def f():

... fd(50)

...>>> screen.onkey(f, "Up")

>>> screen.listen()

>>>

Go 3.10.1

(28)

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 :

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.

turtle.mainloop() turtle.done()

Démarre la boucle d'événements - appelle la boucle principale de Tkinter. Doit être la der- niè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 :

Méthodes de saisie

turtle.textinput(title, prompt)

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

>>> screen.onclick(turtle.goto) # Subsequently clicking into the T

>>> # make the turtle move to the clic

>>> screen.onclick(None) # remove event binding again

>>>

>>> running = True

>>> def f():

... if running:

... fd(50)

... lt(60)

... screen.ontimer(f, 250)

>>> f() ### makes the turtle march around

>>> running = False

>>>

>>> screen.mainloop() >>>

Go 3.10.1

(29)

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'en- trée utilisateur sous forme de chaîne. Si le dialogue est annulé, renvoie None. :

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 fe- nê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. :

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

turtle.colormode(cmode=None)

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

>>> screen.numinput("Poker", "Your stakes:", 1000, minval=10, maxv>>>

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

>>> mode() 'logo'

>>>

Go 3.10.1

(30)

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

turtle.getcanvas()

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

turtle.getshapes()

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

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

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.

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

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

>>>

>>> cv = screen.getcanvas()

>>> cv

<turtle.ScrolledCanvas object ...>

>>>

>>> screen.getshapes()

['arrow', 'blank', 'circle', ..., 'turtle']

>>>

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

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

Go 3.10.1

(31)

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.

turtle.window_height()

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

turtle.window_width()

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

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.

>>> for turtle in screen.turtles():

... turtle.color("red")

>>>

>>> screen.window_height() 480

>>>

>>> screen.window_width() 640

>>>

Go 3.10.1

(32)

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 fe- nê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

turtle.title(titlestring)

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

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

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

Fournis les méthodes liées à l'écran comme setbg(), etc. qui sont décrites ci-dessus.

class turtle.Screen

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

>>> screen.setup (width=200, height=200, startx=0, starty=0)

>>> # sets window to 200x200 pixels, in upper left of

>>> screen.setup(width=.75, height=0.5, startx=None, starty=None)

>>> # sets window to 75% of screen by 50% of screen a

>>>

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

Go 3.10.1

(33)

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 don- née)

Exemple :

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

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

>>>

Go 3.10.1

(34)

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 :

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

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

>>>

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

>>>

Go 3.10.1

(35)

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 à [email protected].)

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

Go 3.10.1

(36)

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.

La configuration native correspondrait au turtle.cfg suivant :

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

Les quatre premières lignes correspondent aux arguments de la méthode Screen.setup().

Les lignes 5 et 6 correspondent aux arguments de la méthode Screen.screensize().

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

Si vous ne voulez utiliser aucune couleur de remplissage (c'est-à-dire rendre la tortue trans- parente), vous devez écrire fillcolor = "" (mais toutes les chaînes non vides ne doivent pas avoir de guillemets dans le fichier cfg).

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 :file:turtle.cfg` dans le dossier où se situe turtle et un autre dans le dossier de travail courant. Ce dernier prendra le dessus.

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

Go 3.10.1