Plus tard ! Les programmes ci-dessous ne sont pas à réaliser le jour de la formation (sauf s'il vous reste du temps bien évidemment). Ils sont là pour vous donner d'autres idées d'exercices (ou vous entraîner si besoin).

Le module turtle permet programmer des dessins. Il est issu de l'ancien langage LOGO. C'est un module qui permet d'aborder de nombreux thèmes en ISN :

la notion de boucles ;
la définition des couleurs (nommées, au format RGB ou héxadécimal) ;
la création de fonctions ;
l'utilisation conjointe avec d'autres modules (math, random, PIL, etc...).

Vous pouvez télécharger un petit résumé au format .pdf des fonctions disponibles en cliquant ici.

Rectangle dégradé

Il faut dessiner le rectangle ci-contre, constitué de barres horizontales de 100 pixels de largeur et 1 pixel de hauteur. Chaque barre a une couleur différente afin de constituer un dégradé depuis la couleur 'red' jusqu'à 'black'.

Quel triplet RGB représente
'red' ? ………………… 'black' ? …………………
Quelle sera la hauteur totale du rectangle une fois terminé ?
Programmer le script Python correspondant à ce dessin.
On pourra se servir du début d'algorithme donné ci-dessous :
Modifier ce programme pour afficher un dégradé de bleu ou de vert...

Une solution


##----- Importation des Modules -----##
from turtle import *

##----- Définition des Fonctions -----##
def retour(crayon, valeur):
    crayon.up()
    crayon.goto(0, valeur)
    crayon.down()

##----- Déclaration des Variables -----##
colormode(255)
stylo = Pen()
stylo.speed(0)

##----- Tracé du dégradé -----##
for i in range(256):
    stylo.pencolor(255-i, 0, 0)			# (0, 0, 255-i) pour le dégradé de bleu...
    stylo.forward(100)
    retour(stylo, i+1)


exitonclick()

Contraintes pour dessiner

Dessiner le yin-yang ci-contre sans utiliser la méthode dot().
Dessiner le yin-yang ci-contre en utilisant uniquement la méthode dot().

Le bleu a pour composantes (34, 26, 209) et le jaune, (254, 211, 11).

Solution n°1
Solution n°2

Yin-Yang en utilisant uniquement la méthode .circle().

Attention au tracé des cercles et des demi-cercles qui est dans le sens direct par défaut. Il faut donner un angle négatif pour un tracé dans le sens indirect...


##----- Importation des Modules -----##
from turtle import *

##----- Définition des Fonctions -----##
def cercle(t, distance, rayon, couleur):
    t.setheading(90)
    t.up()
    t.forward(distance)
    t.setheading(0)
    t.color(couleur)
    t.down()
    t.begin_fill()
    t.circle(rayon)
    t.end_fill()
    t.setheading(90)
    t.up()
    t.forward(2*rayon+distance)
    t.down()

##----- Définition des Variables -----##
stylo = Pen()
colormode(255)
stylo.speed(0)
rayon = 100

##----- Tracé du disque jaune en fond d'image -----##
stylo.color(254, 211, 11)
stylo.begin_fill()
stylo.circle(rayon)
stylo.end_fill()

##----- Tracé du yin bleu -----##
stylo.color(34, 26, 209)
stylo.begin_fill()
stylo.circle(rayon//2, 180)
stylo.left(180)                           # Changement d'orientation pour tracer les demi-cecle en sens indirect
stylo.circle(rayon//2, -180)
stylo.circle(rayon, -180)
stylo.end_fill()

##----- Tracé des disques -----##
cercle(stylo, 30, 20, (34, 26, 209))
cercle(stylo, 30, 20, (254, 211, 11))

stylo.hideturtle()
exitonclick()

Yin-Yang en utilisant uniquement la méthode .dot().


##----- Importation des Modules -----##
from turtle import *
from math import sqrt

##----- Définition des Fonctions -----##
def disque(t, diametre, x, y):
    t.up()
    t.goto(x, y)
    t.down()
    t.dot(diametre)

##----- Définition des Variables -----##
stylo = Pen()
colormode(255)
stylo.speed(0)
rayon = 100

##----- Tracé du disque jaune en fond d'image -----##
stylo.color(254, 211, 11)
disque(stylo, 2*rayon, 0, 0)

##----- Tracé du yin bleu - On suit l'équation du demi-cercle de rayon : rayon/2-----##
stylo.color(34, 26, 209)
for x in range(int(rayon/2)+1):
    disque(stylo, rayon, x, sqrt((rayon/2)**2-x**2))
    disque(stylo, rayon, x, -sqrt((rayon/2)**2-x**2))
stylo.color(254, 211, 11)
disque(stylo, rayon, 0, -rayon/2)

##----- Tracé des disques -----##
disque(stylo, rayon*2/5, 0, rayon/2)
stylo.color(34, 26, 209)
disque(stylo, rayon*2/5, 0, -rayon/2)

stylo.hideturtle()
exitonclick()

Arc-en-ciel

Établir un algorithme permettant de tracer un dégradé de 1280 couleurs de l'arc-en-ciel, du rouge au violet puis reproduire la figure ci-dessous, de 100 pixels de hauteur.

Une piste
Une solution

L'algorithme a déjà été etudié dans cet exercice.


##----------Importation des modules---------##
from turtle import *

##----------Définition des Fonctions----------##
def degrade(x):
    """Cette fonction renvoie le triplet de composantes correspondant
    à une valeur x comprise entre 0 et 1279 = 5*256-1."""
    r, v, b = 0, 0, 0
    if 0 <= x <= 255:
        r, v, b = 255, x, 0
    elif 256 <= x <= 511:
        r, v, b = 511-x, 255, 0
    elif 512 <= x <= 767:
        r, v, b = 0, 255, x-512
    elif 768 <= x <= 1023:
        r, v, b = 0, 1023-x, 255
    elif 1024 <= x <= 1279:
        r, v, b = x-1024, 0, 255
    return (r, v, b)

def retour(t, x, y):
    t.up()
    t.goto(x, y)
    t.down()


##----- Déclaration des Variables -----##
colormode(255)
stylo = Pen()
depart = -640

##----------Programme Principal----------##
stylo.speed(0)
stylo.setheading(90)

for i in range(1280):
    retour(stylo, depart, 0)
    stylo.color(degrade(i))
    stylo.forward(100)
    depart += 1
    
exitonclick()

Série de figures

Concevoir un programme utilisant la fonction degrade() de l'exercice précédent pour tracer les figures ci-dessous, selon la valeur de l'entier k saisi par l'utilisateur (Il y a 20 couleurs distinctes).

`k = 1`	`k = 2`	`k = 5`	`k = 8`

Une solution


##----------Importation des modules---------##
from turtle import *

##----------Définition des Fonctions----------##
def degrade(x):
    """Cette fonction renvoie le triplet de composantes correspondant
    à une valeur x comprise entre 0 et 1279 = 5*256-1."""
    r, v, b = 0, 0, 0
    if 0 <= x <= 255:
        r, v, b = 255, x, 0
    elif 256 <= x <= 511:
        r, v, b = 511-x, 255, 0
    elif 512 <= x <= 767:
        r, v, b = 0, 255, x-512
    elif 768 <= x <= 1023:
        r, v, b = 0, 1023-x, 255
    elif 1024 <= x <= 1279:
        r, v, b = x-1024, 0, 255
    return (r, v, b)

def triangle(t, dist):
    """Tracé d'un triangle équilatéral."""
    for i in range(3):
        t.forward(dist)
        t.right(120)

def toile(t):
    """Tracé d'un triangle de couleur "arc-en-ciel"."""
    dist = 0
    for i in range(20):
        dist += 5
        t.color(degrade(1280-64*i))
        triangle(t, dist)

def boucle(t, n):
    """Tracé de n triangles de couleur "arc-en-ciel"."""
    for i in range(n):
        toile(t)
        t.left(360//n)
    


##----- Déclaration des Variables -----##
colormode(255)
stylo = Pen()
n = int(numinput('Saisie d\'un nombre',
                 'Donner le nombre de triangles à tracer'))
angle = 360//n

##----------Programme Principal----------##
stylo.speed(0)

for i in range(n):
        toile(stylo)
        stylo.left(angle)

stylo.hideturtle()
exitonclick()

Image cachée ?

Dans cet exercice, une chaîne de caractère va servir d'instruction au crayon du module turtle. Le programme à concevoir doit :

Demander à l'utilisateur un texte uniquement composé de '0' et de '1' (inutile de gérer les exceptions) ;
Parcourir les caractères du texte ;
Dessiner un petit point blanc (rayon 3) pour chaque '0' lu ;
Dessiner un gros point noir (rayon 20) pour chaque '1' lu ;
Avancer de 1 entre deux caractères ;
Aller au début de la ligne suivante tous les 20 caractères.

On donne ci-dessous un début de programme, à compléter en utilisant au moins une fonction.


##----- Importation des modules -----##
from turtle import *

##----- Définition des Fonctions -----##
# A compléter...

##----- Programme Principal -----##
setworldcoordinates(-32,-32, 12,12)					# Pour un affichage optimal
stylo = Pen()
stylo.speed(0)
stylo.up()
stylo.setposition(-20, 0)

# A compléter...

stylo.hideturtle()
exitonclick()

On pourra tester le programme avec les textes à tester qui permettront très vite de voir si le programme est correct ou non (inutile de tenir compte des backlash «\» : ils seront ignorés par Python et ne sont là que pour faciliter la mise en page).

Textes à tester
Dessin n°1
Dessin n°2
Dessin n°3

'0000000001000000000000000000101000000000000000010001000000000000001000\ 0010000000000001000000010000000000100000000010000000010000000000010000\ 0010000000000000100001000000000000000100100000000000000000101000000000\ 0000000001010000000000000000100010000000000000010000010000000000001000\ 0000100000000001000000000100000000100000000000100000010000000000000100\ 00100000000000000010010000000000000000011000000000'
'0000001000000100000000000010000001000000000000100000010000000000001000\ 0001000000000000100000010000000000001000000100000011111111111111111111\ 0000001000000100000000000010000001000000000000100000010000000000001000\ 0001000000000000100000010000000000001000000100000011111111111111111111\ 0000001000000100000000000010000001000000000000100000010000000000001000\ 00010000000000001000000100000000000010000001000000'
'0000000111111000000000000111101111100000000011000000001110000011100000\ 0000001100001100000000000001000110000100000100011001000111100011100011\ 1100011100011110001111000001000001000001100000000000000000111100000000\ 0000000001110010000000000100111100010000000010001101000110000001100011\ 0110001110011100001000110001111110001100000110000000000011000000110000\ 00001110000000011110101110000000000001111111000000'


##----- Importation des modules -----##
from turtle import *

##----- Définition des Fonctions -----##
def dessiner(t, car):
	"""Cette fonction force le crayon t à tracer un petit
		point blanc lorsque car vaut '0' et un gros point
		noir lorsque car vaut '1'."""
	if car == '0':
		t.dot(3, "white")
	else:
		t.dot(20, "black")


def deplacer(t, n):
	"""Cette fonction déplace le crayon t selon la valeur
		de l'entier n. Lorsque n est un multiple de 20
		(n = 20*k), on replace le crayon aux coordonnées
		(-20, -k) sinon le crayon avance de 1."""
	t.up()
	if n%20 == 0:
		t.goto(-20, -n//20)
	else:
		t.forward(1)



##----- Programme Principal -----##
setworldcoordinates(-32,-32, 12,12)					# Pour un affichage optimal
stylo = Pen()
stylo.speed(0)
stylo.up()
stylo.setposition(-20, 0)

texte = '0000000001000000000000000000101000000000000000010001000000000000001000\
0010000000000001000000010000000000100000000010000000010000000000010000\
0010000000000000100001000000000000000100100000000000000000101000000000\
0000000001010000000000000000100010000000000000010000010000000000001000\
0000100000000001000000000100000000100000000000100000010000000000000100\
00100000000000000010010000000000000000011000000000'

for i in range(len(texte)):
	dessiner(stylo, texte[i])
	deplacer(stylo, i+1)							# Obligatoire pour une division correcte par 20

stylo.hideturtle()
exitonclick()


##----- Importation des modules -----##
from turtle import *

##----- Définition des Fonctions -----##
def dessiner(t, car):
	"""Cette fonction force le crayon t à tracer un petit
		point blanc lorsque car vaut '0' et un gros point
		noir lorsque car vaut '1'."""
	if car == '0':
		t.dot(3, "white")
	else:
		t.dot(20, "black")


def deplacer(t, n):
	"""Cette fonction déplace le crayon t selon la valeur
		de l'entier n. Lorsque n est un multiple de 20
		(n = 20*k), on replace le crayon aux coordonnées
		(-20, -k) sinon le crayon avance de 1."""
	t.up()
	if n%20 == 0:
		t.goto(-20, -n//20)
	else:
		t.forward(1)



##----- Programme Principal -----##
setworldcoordinates(-32,-32, 12,12)					# Pour un affichage optimal
stylo = Pen()
stylo.speed(0)
stylo.up()
stylo.setposition(-20, 0)

texte = '0000001000000100000000000010000001000000000000100000010000000000001000\
0001000000000000100000010000000000001000000100000011111111111111111111\
0000001000000100000000000010000001000000000000100000010000000000001000\
0001000000000000100000010000000000001000000100000011111111111111111111\
0000001000000100000000000010000001000000000000100000010000000000001000\
00010000000000001000000100000000000010000001000000'

for i in range(len(texte)):
	dessiner(stylo, texte[i])
	deplacer(stylo, i+1)							# Obligatoire pour une division correcte par 20

stylo.hideturtle()
exitonclick()


##----- Importation des modules -----##
from turtle import *

##----- Définition des Fonctions -----##
def dessiner(t, car):
	"""Cette fonction force le crayon t à tracer un petit
		point blanc lorsque car vaut '0' et un gros point
		noir lorsque car vaut '1'."""
	if car == '0':
		t.dot(3, "white")
	else:
		t.dot(20, "black")


def deplacer(t, n):
	"""Cette fonction déplace le crayon t selon la valeur
		de l'entier n. Lorsque n est un multiple de 20
		(n = 20*k), on replace le crayon aux coordonnées
		(-20, -k) sinon le crayon avance de 1."""
	t.up()
	if n%20 == 0:
		t.goto(-20, -n//20)
	else:
		t.forward(1)



##----- Programme Principal -----##
setworldcoordinates(-32,-32, 12,12)					# Pour un affichage optimal
stylo = Pen()
stylo.speed(0)
stylo.up()
stylo.setposition(-20, 0)

texte = '0000000111111000000000000111101111100000000011000000001110000011100000\
0000001100001100000000000001000110000100000100011001000111100011100011\
1100011100011110001111000001000001000001100000000000000000111100000000\
0000000001110010000000000100111100010000000010001101000110000001100011\
0110001110011100001000110001111110001100000110000000000011000000110000\
00001110000000011110101110000000000001111111000000'

for i in range(len(texte)):
	dessiner(stylo, texte[i])
	deplacer(stylo, i+1)							# Obligatoire pour une division correcte par 20

stylo.hideturtle()
exitonclick()