turtle --- Turtle graphics

Code Source : Lib/turtle.py

---

Turtle star

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

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

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

This document includes four main sections:

• Tutoriel teaches the basics of turtle drawing.

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

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

• Explication provides background on the object-oriented interface.

Note

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

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 Standard library module '_tkinter' was not found error, you'll have to install the Tk interface package on your system.

Nothing appears yet. To open the turtle window, make the turtle visible:

showturtle()

A new window opens, with the turtle in the middle, shown as an arrow heading East.

Basic drawing

Send the turtle forward 100 steps:

forward(100)

You should see 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(). Many commands also have shorter aliases, such as fd() for forward().

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:

start = pos()

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

distance(start) < 1 is a good way to know when the turtle is back at its start position.

Finally, complete the filling:

end_fill()

(Note that filling only actually takes place when you give the end_fill() command.)

Reference

Turtle methods and functions

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

Bouger et dessiner

turtle.forward(distance)

turtle.fd(distance)

Paramètres:

distance -- un nombre

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

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

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

turtle.right(angle)

turtle.rt(angle)

Paramètres:

angle -- un nombre

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

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

turtle.left(angle)

turtle.lt(angle)

Paramètres:

angle -- un nombre

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

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

turtle.goto(x, y=None)

turtle.setpos(x, y=None)

turtle.setposition(x, y=None)

Paramètres:

• x -- un nombre ou une paire / un vecteur de nombres

• y -- un nombre ou None

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

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

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

Paramètres:

• x -- un nombre ou None

• y -- un nombre ou None

• fill_gap -- a boolean

Teleport, or instantly move, the turtle to an absolute position. Unlike goto(), no line is drawn. If x or y is not given, that coordinate is kept as it is. The turtle's heading does not change.

If the turtle is filling a shape, the shape drawn so far is finished and filled before teleporting, and filling starts again at the new position. Pass fill_gap=True to keep filling one shape instead. The teleport then counts as an edge of the shape, as it would with goto().

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

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

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

turtle.sety(y)

Paramètres:

y -- un nombre

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

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

turtle.setheading(to_angle)

turtle.seth(to_angle)

Paramètres:

to_angle -- un nombre

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

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

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

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

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

Paramètres:

• radius -- un nombre

• extent -- un nombre ou None

• steps -- un entier ou None

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

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

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

turtle.dot()

turtle.dot(size)

turtle.dot(color, /)

turtle.dot(size, color, /)

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

Paramètres:

• size -- a positive integer or None

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

Draw a circular dot with diameter size, using color. If size is not given, the larger of pensize + 4 and 2 * pensize is used. If color is not given, the current pencolor is used.

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

Stamp a copy of the turtle shape onto the canvas and return its id. The stamp is placed at the current turtle position. The returned id can be used to delete the stamp with clearstamp().

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

turtle.clearstamp(stampid)

Paramètres:

stampid -- an integer

Delete the stamp with the given stampid. stampid must be the return value of a previous stamp() call.

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

Delete all or the first or last n of the turtle's stamps. If n is not given, delete all stamps. If n is positive, delete the first n stamps. If n is negative, delete the last n stamps, so -2 deletes the last two.

>>> 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 -- an integer, a string or None

Return or set the turtle's speed. If speed is not given, return the current speed. Otherwise set the turtle's speed to an integer from 0 to 10. If speed is a number greater than 10 or smaller than 0.5, the speed is set to 0. You can also use these names instead of numbers:

• "fastest": 0

• "fast": 10

• "normal": 6

• "slow": 3

• "slowest": 1

Speeds from 1 to 10 give increasingly faster animation of line drawing and turtle turning. A speed of 0 means that no animation takes place: forward() and back() make the turtle jump, and likewise left() and right() make the turtle turn instantly.

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

Return the turtle's current location (x,y) as a Vec2D vector.

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

Return the angle of the line from the turtle's position to (x,y). If y is None, x must be a pair of coordinates, a Vec2D, for example as returned by pos(), or another turtle. The angle is measured from the turtle's start orientation, which depends on the turtle mode, see mode().

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

turtle.xcor()

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

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

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

turtle.distance(x, y=None)

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

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

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

Paramètres de mesure

turtle.degrees(fullcircle=360.0)

Paramètres:

fullcircle -- un nombre

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

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

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

turtle.radians()

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

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

Réglage des stylos

État des stylos

turtle.pendown()

turtle.pd()

turtle.down()

Lower the pen. The turtle draws a line when it moves.

turtle.penup()

turtle.pu()

turtle.up()

Lift the pen. The turtle does not draw when it moves.

turtle.pensize(width=None)

turtle.width(width=None)

Paramètres:

width -- a positive number or None

Return or set the line thickness. If width is not given, return the current pensize. If resizemode is set to "auto" and the turtle shape is a polygon, that polygon is drawn with the same line thickness.

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

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

Paramètres:

• pen -- a dictionary or None

• pendict -- keyword arguments with the keys below

Return or set the pen's attributes. The attributes are returned as a dictionary with the following keys and values:

• "shown": True or False

• "pendown": True or False

• "pencolor": a color string or a color tuple

• "fillcolor": a color string or a color tuple

• "pensize": a positive number

• "speed": a number from 0 to 10

• "resizemode": "auto", "user" or "noresize"

• "stretchfactor": a pair of positive numbers

• "shearfactor": a number

• "outline": a positive number

• "tilt": a number

Such a dictionary can be passed as pen to restore a former pen state. The attributes can also be given as keyword arguments, which can be used to set several of them in one statement.

>>> turtle.pen(fillcolor="black", pencolor="red", pensize=10)
>>> turtle.pen()
{'shown': True, 'pendown': True, 'pencolor': 'red', 'fillcolor': 'black',
 'pensize': 10, 'speed': 9, 'resizemode': 'noresize',
 'stretchfactor': (1.0, 1.0), 'shearfactor': 0.0, 'outline': 1,
 'tilt': 0.0}
>>> penstate = turtle.pen()
>>> turtle.color("yellow", "")
>>> turtle.penup()
>>> turtle.pen()["pencolor"]
'yellow'
>>> # restore the saved pen state, but with a green fill
>>> turtle.pen(penstate, fillcolor="green")
>>> turtle.pen()["pencolor"]
'red'
>>> turtle.pen()["fillcolor"]
'green'

turtle.isdown()

Return True if the pen is down, False if it's up.

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

Réglage des couleurs

turtle.pencolor()

turtle.pencolor(color, /)

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

Renvoie ou règle la couleur du stylo.

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

pencolor()

Return the current pencolor as color specification string or as a tuple (see example). May be used as input to another color(), pencolor(), fillcolor() or bgcolor() call.

pencolor(colorstring)

Set the pencolor to colorstring, which is a Tk color specification string, such as "red", "yellow", or "#33cc8c".

pencolor((r, g, b))

Set the pencolor to the RGB color represented by the tuple of r, g, and b. Each of r, g, and b must be between 0 and colormode, where colormode is either 1.0 or 255 (see colormode()).

pencolor(r, g, b)

Set the pencolor to the RGB color represented by r, g, and b. Each of r, g, and b must be between 0 and colormode.

If the turtle shape is a polygon, the outline of that polygon is drawn with the newly set pencolor.

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

turtle.fillcolor()

turtle.fillcolor(color, /)

turtle.fillcolor(r, g, b, /)

Renvoie ou règle la couleur de remplissage.

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

fillcolor()

Return the current fillcolor as color specification string, possibly in tuple format (see example). May be used as input to another color(), pencolor(), fillcolor() or bgcolor() call.

fillcolor(colorstring)

Set the fillcolor to colorstring, which is a Tk color specification string, such as "red", "yellow", or "#33cc8c".

fillcolor((r, g, b))

Set the fillcolor to the RGB color represented by the tuple of r, g, and b. Each of r, g, and b must be between 0 and colormode, where colormode is either 1.0 or 255 (see colormode()).

fillcolor(r, g, b)

Set the fillcolor to the RGB color represented by r, g, and b. Each of r, g, and b must be between 0 and colormode.

If the turtle shape is a polygon, the interior of that polygon is drawn with the newly set fillcolor.

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

turtle.color()

turtle.color(color, /)

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

turtle.color(pencolor, fillcolor, /)

Return or set the pencolor and fillcolor.

Several input formats are allowed. They use 0 to 3 arguments as follows:

color()

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

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

Inputs as in pencolor(). Set both the pencolor and the fillcolor to the given value.

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

If the turtle shape is a polygon, the outline and interior of that polygon are drawn with the newly set colors.

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

Return True if the turtle is filling, False otherwise.

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

turtle.fill()

Fill the shape drawn in the with block.

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

fill() is a context manager, so using it is the same as calling begin_fill() before the block and end_fill() after it:

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

Ajouté dans la version 3.14.

turtle.begin_fill()

Call just before drawing a shape to be filled. The shape is filled by the next call to end_fill().

turtle.end_fill()

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

If the shape crosses itself or several shapes overlap, whether the overlapping parts are filled depends on the operating system, the type of overlap and how many there are. For example, the turtle star above may be either all yellow or have some white regions.

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

Plus des réglages pour le dessin

turtle.reset()

Delete the turtle's drawings and re-center the turtle. The turtle's settings are restored to their default values.

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

Delete the turtle's drawings from the screen. The state and position of the turtle as well as the drawings of other turtles are not affected.

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

Paramètres:

• arg -- an object

• move -- a boolean

• align -- a string

• font -- a tuple of a string, an integer and a string

Write text at the current turtle position. The text is the string representation of arg. align is one of the strings "left", "center" or "right" and says how the text is placed relative to the turtle position. font is a triple of font name, font size and font type. If move is True, the pen is moved to the bottom-right corner of the text.

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

État de la tortue

Visibilité

turtle.hideturtle()

turtle.ht()

Make the turtle invisible. If the pen is down, movement still draws.

turtle.showturtle()

turtle.st()

Rend la tortue visible.

turtle.isvisible()

Return True if the turtle is visible, False if it's hidden.

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

Apparence

turtle.shape(name=None)

Paramètres:

name -- a string or None

Set the turtle shape to the named shape. If name is not given, return the name of the current shape. The shape must exist in the TurtleScreen's shape dictionary. Initially there are the following shapes: "arrow", "turtle", "circle", "square", "triangle" and "classic". To add shapes, see the Screen method register_shape().

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

turtle.resizemode(rmode=None)

Paramètres:

rmode -- a string or None

Set the resizemode to "auto", "user" or "noresize". If rmode is not given, return the current resizemode. The different resizemodes have the following effects:

• "auto": the turtle is resized according to the value of pensize().

• "user": the turtle is resized according to the stretch factors and outline width, which are set by shapesize().

• "noresize": the turtle is not resized.

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

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

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

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

Paramètres:

• stretch_wid -- a positive number or None

• stretch_len -- a positive number or None

• outline -- a positive number or None

Return or set the turtle's stretch factors and outline width. If no arguments are given, return the current values. Otherwise set resizemode to "user", so that the turtle is displayed stretched according to its stretch factors:

• stretch_wid: the stretch factor perpendicular to the turtle's heading

• stretch_len: the stretch factor in the direction of the turtle's heading

• outline: the width of the shape's outline

For example, shapesize(2, 1) makes the turtle twice as wide without changing its length. If only stretch_wid is given, stretch_len is set to the same value.

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

Return or set the current shear factor. Shearing slants the turtle shape, like the slant of italic letters. The shear factor says how much it is slanted: 0 is not slanted at all, and the larger the number, the stronger the slant. Negative numbers slant the other way. If shear is not given, return the current shear factor. Otherwise slant the turtle shape accordingly and set resizemode to "user". The turtle's heading does not change. Precisely, the shear factor is the tangent of the shear angle.

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

turtle.tilt(angle)

Paramètres:

angle -- un nombre

Turn the turtle shape by angle from its current tilt angle. The turtle's heading does not change, so the turtle keeps moving in the same direction. See tiltangle().

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

Return or set the current tilt angle. The tilt angle is the angle between the direction the turtle shape points in and the direction the turtle moves in. Normally the shape points in the direction of movement, so the tilt angle is 0. If angle is given, turn the turtle shape to that tilt angle, no matter what it was before, and set resizemode to "user". The turtle's heading does not change. If angle is not given, return the current tilt angle.

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

• t12 -- un nombre ou None

• t21 -- un nombre ou None

• t22 -- un nombre ou None

Return or set the transformation matrix of the turtle shape. The matrix combines the stretch factors, the shear factor and the tilt angle of the turtle shape into four numbers: t11 and t12 form its first row, t21 and t22 its second. If none of them are given, return the current matrix as a tuple of four numbers. Otherwise set the given elements and update the stretch factors, shear factor and tilt angle accordingly. t11 * t22 - t12 * t21 must not be zero, otherwise an error is raised.

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

Return the points that form the outline of the current turtle shape as a tuple of (x, y) coordinate pairs. These points can be used to define a new shape or parts of a compound shape

>>> 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 -- a function with two arguments or None

• btn -- an integer

• add -- a boolean or None

Bind fun to mouse-click events on this turtle. fun is called with the coordinates of the clicked point on the canvas. If fun is None, existing bindings are removed. btn is the number of the mouse button and defaults to 1, the left mouse button. If add is True, a new binding is added, otherwise it replaces a former binding. Example for the anonymous turtle, that is, the procedural way:

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

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

Paramètres:

• fun -- une fonction à deux arguments qui sera appelée avec les coordonnées du point cliqué sur le canevas

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

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

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

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

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

Paramètres:

• fun -- une fonction à deux arguments qui sera appelée avec les coordonnées du point cliqué sur le canevas

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

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

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

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

>>> turtle.ondrag(turtle.goto)

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

Méthodes spéciales de la tortue

turtle.poly()

Record the vertices of a polygon drawn in the with block. The first and last vertices will be connected.

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

poly() is a context manager, so using it is the same as calling begin_poly() before the block and end_poly() after it:

>>> turtle.begin_poly()
>>> turtle.forward(100)
>>> turtle.right(60)
>>> turtle.forward(100)
>>> turtle.end_poly()

Ajouté dans la version 3.14.

turtle.begin_poly()

Start recording the vertices of a polygon. The current turtle position is the first vertex of the polygon.

turtle.end_poly()

Stop recording the vertices of a polygon. The current turtle position is the last vertex of the polygon. This will be connected with the first vertex.

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

Create and return a clone of the turtle. The clone has the same position, heading and turtle properties.

>>> leonel = Turtle()
>>> marco = leonel.clone()

turtle.getturtle()

turtle.getpen()

Return the Turtle object itself.

Call getturtle() to get the turtle used by functions such as forward() and left():

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

Set or disable the undo buffer. If size is an integer, an empty undo buffer of the given size is installed. size is the maximum number of turtle actions that can be undone by undo(). If size is None, the undo buffer is disabled.

>>> turtle.setundobuffer(42)

turtle.undobufferentries()

Return the number of entries in the undo buffer.

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

Screen methods and functions

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

turtle.bgcolor(color, /)

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

Return or set the background color of the TurtleScreen.

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

bgcolor()

Return the current background color as a color specification string or as a tuple (see example). May be used as input to another color(), pencolor(), fillcolor() or bgcolor() call.

bgcolor(colorstring)

Set the background color to colorstring, which is a Tk color specification string, such as "red", "yellow", or "#33cc8c".

bgcolor((r, g, b))

Set the background color to the RGB color represented by the tuple of r, g, and b. Each of r, g, and b must be between 0 and colormode, where colormode is either 1.0 or 255 (see colormode()).

bgcolor(r, g, b)

Set the background color to the RGB color represented by r, g, and b. Each of r, g, and b must be between 0 and colormode.

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

turtle.bgpic(picname=None)

Paramètres:

picname -- a string or None

Set the background image or return the name of the current one. If picname is the name of an image file (PNG, GIF, PGM, and PPM), set that image as the background. If picname is "nopic", delete the background image, if present. If picname is None, return the filename of the current background image.

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

turtle.clear()

Note

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

turtle.clearscreen()

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

turtle.reset()

Note

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

turtle.resetscreen()

Reset all turtles on the screen to their initial state.

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

Paramètres:

• canvwidth -- a positive integer or None

• canvheight -- a positive integer or None

• bg -- a colorstring or a color tuple or None

Resize the canvas the turtles are drawing on. canvwidth and canvheight are the new width and height of the canvas in pixels, and bg is the new background color. If no arguments are given, return the current canvas width and height.

The drawing window is not altered. To see hidden parts of the canvas, use the scrollbars. This can make visible those parts of a drawing which were outside the canvas before, for example to find a turtle that has wandered off the canvas.

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

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

Paramètres:

• llx -- un nombre

• lly -- un nombre

• urx -- un nombre

• ury -- un nombre

Set up a user-defined coordinate system. llx and lly are the x and y coordinates of the lower left corner of the canvas. urx and ury are the x and y coordinates of the upper right corner. Switch to mode "world" if necessary, which performs a reset. If mode "world" is already active, all drawings are redrawn according to the new coordinates. In user-defined coordinate systems, angles may appear distorted, see mode().

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

Temporarily turn off turtle animation. The code inside the with block is not animated. Once the block is exited, the drawing appears. This is useful for drawing complex shapes where even the fastest speed setting is too slow.

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

Ajouté dans la version 3.14.

turtle.delay(delay=None)

Paramètres:

delay -- a nonnegative integer or None

Return or set the drawing delay in milliseconds. This is approximately the time interval between two consecutive canvas updates. The longer the drawing delay, the slower the animation.

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

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

Paramètres:

• n -- a nonnegative integer or None

• delay -- a nonnegative integer or None

Turn turtle animation on or off and set the drawing delay. If n is given, only every n-th regular screen update is performed, which can be used to speed up the drawing of complex graphics. If n is 0, animation is turned off and the screen is only updated by calling update(). If delay is given, it sets the drawing delay, see delay(). When called without arguments, return the current value of n.

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

Paramètres:

• xdummy -- ignored

• ydummy -- ignored

Set focus on the TurtleScreen so that it receives key events. The two dummy arguments are only there so that listen() can be passed to onclick().

turtle.onkey(fun, key)

turtle.onkeyrelease(fun, key)

Paramètres:

• fun -- une fonction sans arguments ou None

• key -- a string

Bind fun to the key-release event of key. key is a key, such as "a", or a key symbol, such as "space". If fun is None, the event binding is removed. To be able to receive key events, the TurtleScreen must have focus, see listen().

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

The turtle can then be moved by repeatedly pressing the up-arrow key, drawing a hexagon.

turtle.onkeypress(fun, key=None)

Paramètres:

• fun -- une fonction sans arguments ou None

• key -- a string or None

Bind fun to the key-press event of key. key is a key, such as "a", or a key symbol, such as "space". If key is not given, fun is bound to the key-press event of any key. If fun is None, the event binding is removed. To be able to receive key events, the TurtleScreen must have focus, see listen().

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

The turtle can then be moved by pressing or holding down the up-arrow key, drawing a hexagon.

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

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

Paramètres:

• fun -- a function with two arguments or None

• btn -- an integer

• add -- a boolean or None

Bind fun to mouse-click events on this screen. fun is called with the coordinates of the clicked point on the canvas. If fun is None, existing bindings are removed. btn is the number of the mouse button and defaults to 1, the left mouse button. If add is True, a new binding is added, otherwise it replaces a former binding.

Exemple pour une instance de TurtleScreen nommée screen et une instance Turtle nommée turtle :

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

Note

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

turtle.ontimer(fun, t=0)

Paramètres:

• fun -- une fonction sans arguments

• t -- a nonnegative number

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

Start the event loop by calling Tkinter's mainloop() method. Must be the last statement in a turtle graphics program. Must not be used if a script is run from within IDLE in -n mode (see Exécution sans sous-processus).

Méthodes de saisie

turtle.textinput(title, prompt)

Paramètres:

• title -- a string

• prompt -- a string

Pop up a dialog window for input of a string. title is the title of the dialog window and prompt is a text describing what information to input. Return the string entered. If the dialog is canceled, return None.

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

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

Paramètres:

• title -- a string

• prompt -- a string

• default -- un nombre ou None

• minval -- un nombre ou None

• maxval -- un nombre ou None

Pop up a dialog window for input of a number. title is the title of the dialog window and prompt is a text describing what numerical information to input. default is the default value, minval and maxval are the minimum and maximum values for input. If these are given, the number entered must be between minval and maxval. If not, a hint is issued and the dialog remains open for correction. Return the number entered. 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 -- a string or None

Set the turtle mode and perform a reset. mode is one of the strings "standard", "logo" or "world". If mode is not given, return the current mode.

Mode "standard" is compatible with the old turtle module. Mode "logo" is compatible with most Logo turtle graphics. Mode "world" uses user-defined world coordinates, see setworldcoordinates(). In this mode, angles appear distorted if the x and y units are not of equal length.

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 -- un nombre ou None

Return the colormode or set it to 1.0 or 255. After setting it, the r, g and b values of color triples have to be between 0 and 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)

Paramètres:

• name -- a string

• shape -- a string, a tuple of pairs of numbers, a Shape object or None

Add a turtle shape to the TurtleScreen's shape list. It can be called in four different ways:

1. name is the name of an image file (PNG, GIF, PGM, and PPM) and shape is None: Install the corresponding image shape.

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

2. name is an arbitrary string and shape is the name of an image file (PNG, GIF, PGM, and PPM): Install the corresponding image shape.

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

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

4. name is an arbitrary string and shape is a (compound) Shape object: Install the corresponding compound shape.

Image shapes do not rotate when turning the turtle, so they do not display the heading of the turtle. To use a registered shape, call shape() with its name.

Modifié dans la version 3.14: Added support for PNG, PGM, and PPM image formats. Both a shape name and an image file name can be specified.

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

Screen-only methods

turtle.bye()

Close the turtle graphics window.

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.save(filename, *, overwrite=False)

Paramètres:

• filename -- a string

• overwrite -- a boolean

Save the current drawing and the turtles as a PostScript file. filename is the path of the file to create. It must end with ".ps" or ".eps". If a file with that name already exists, a FileExistsError is raised, unless overwrite is True. overwrite must be given by name, as in overwrite=True.

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

Ajouté dans la version 3.14.

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

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

Paramètres:

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

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

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

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

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

turtle.title(titlestring)

Paramètres:

titlestring -- a string

Set the title of the turtle window to titlestring. The title is shown in the title bar of the turtle graphics window.

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

Classes publiques

class turtle.RawTurtle(canvas)

class turtle.RawPen(canvas)

Paramètres:

canvas -- a tkinter.Canvas, a ScrolledCanvas or a 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 -- a tkinter.Canvas

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

class turtle.Screen

Subclass of TurtleScreen, with four methods added. Calling Screen() returns the single screen object. If it does not exist yet, it is created. Otherwise the existing one is returned.

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_ -- a string

• data -- depends on type_

Data structure modeling shapes. type_ is one of the strings "polygon", "image" or "compound". What data must be depends on type_: for "polygon" a tuple of pairs of coordinates, for "image" an image (only used internally), and for "compound" None, as a compound shape is built up using the addcomponent() method.

addcomponent(poly, fill, outline=None)

Paramètres:

• poly -- a tuple of pairs of numbers

• fill -- a color

• outline -- a color or None

Add a component to a shape of type "compound". poly is a polygon, a tuple of pairs of numbers. fill is the color the polygon is filled with and outline is the color of its outline. If outline is not given, fill is used for it as well.

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 How to use compound shapes.

class turtle.Vec2D(x, y)

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

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

• a + b addition de vecteurs

• a - b soustraction de deux vecteurs

• a * b produit scalaire

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

• abs(a) valeur absolue de a

• a.rotate(angle) rotation

Exceptions

The turtle module defines the following exception:

exception turtle.TurtleGraphicsError

Raised for invalid arguments or operations. For example, a malformed color string:

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

How-to guides

This section covers some typical turtle use-cases and approaches.

How to automatically begin and end filling

Starting with Python 3.14, you can use the fill() context manager instead of begin_fill() and end_fill() to automatically begin and end fill. Here is an example:

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

forward(200)

The code above is equivalent to:

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

forward(200)

How to use compound shapes

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

1. Create an empty Shape object of type "compound".

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

   Par exemple :

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

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

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

How to 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.)

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

How to use object-oriented turtle graphics

Voir aussi

Explanation of the object-oriented interface

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

How to use help()

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.

If you (or your students) want to use turtle with online help in your native language, you have to translate the docstrings and save the resulting file as e.g. turtle_docstringdict_german.py.

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 docstringdict turtle_docstringdict_italian.py will be loaded at import time (if present on the import path, e.g. in the same directory as turtle).

• 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 prevent exitonclick() to enter the mainloop.

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

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

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.

turtledemo --- Demo scripts

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

python -m turtledemo

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

python -m turtledemo.bytedesign

The turtledemo package directory contains:

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

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

• 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	tracer(), delay(), update()
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	turtles as clock's hands, ontimer()
colormixer	des expériences en rouge, vert, bleu	ondrag()
forest	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ï	Rectangular Turtles as Hanoi discs (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	programme de dessin extra minimaliste	onclick()
peace	basique	tortue : apparence et animation
penrose	tuiles apériodiques avec cerfs-volants et fléchettes	stamp()
planet_and_moon	simulation d'un système gravitationnel	formes composées, Vec2D
rosette	un motif issu de l'article de wikipedia sur la tortue graphique	clone(), undo()
round_dance	tortues dansantes tournant par paires en sens inverse	compound shapes, clone() shapesize(), tilt(), get_shapepoly(), update()
sorting_animate	démonstration visuelle des différentes méthodes de classement	alignement simple, répartition aléatoire
tree	un arbre (tracé) par un parcours en largeur (à l’aide de générateurs)	clone()
two_canvases	design simple	tortues sur deux canevas
yinyang	un autre exemple élémentaire	circle()

Amusez-vous !