On souhaite réaliser avec le module turtle (Tortue) le dessin des 3 carrés ci-contre – il ne faut pas dessiner la grille en bleue.

Je vous donne la structure de fichier de base, à compléter.

from turtle import *

# initialisation
speed(5)
shape("turtle")
pencolor("red")
pensize(4)
setheading(0)

# tracé - à compléter

# tfin de la zone à compléter
exitonclick()

On identifie facilement les morceaux de codes dessinant les carrés. Ils sont 3 fois identiques : lignes 12-14 ; 18 - 20 ; 24 - 26.

Cette façon de faire a deux gros défauts :

• On est obligé de réécrire plusieurs fois la même chose,
• On ne voit pas clairement ce que fait le programme.

L'idée est d'associer un nom au bloc

for i in range(4):
    forward(100)
    left(90)

De préférence, un nom qui parle et qui évite des explications.

def tracer_carre_100():
    for i in range(4):
        forward(100)
        left(90)

Le rôle des () sera plus clair plus loin.

Vous comprenez qu'ici, tracer_carre_100() remplace toujours le même morceau de programme. C'est ce qu'on appelle une macro.

Notre fonction ne sait tracer que des carré de côté 100. Que ferons nous si nous voulons tracer un carré de côté 50 ? Faudra-t-il définir une autre fonction ?

Bien sûr que non. On peut fournir à la fonction un argument qui agit comme un paramètre de réglage de la fonction.

def tracer_carre(taille):
    for i in range(4):
        forward(taille)
        left(90)

Lorsque l'on appellera la fonction, il faudra fournir une valeur pour taille.

Pour rendre le programme encore plus clair, on documente la fonction, c'est à dire que l'on ajoute un commentaire juste après la signature.

def tracer_carre(taille):
    """
    Trace un carré
    taille: dimension du côté
    """
    for i in range(4):
        forward(taille)
        left(90)

Le bloc correspondant au déplacement de crayon levé se retrouve aussi beaucoup. On peut lui associer une macro. Mais il y a une différence : le crayon ne se déplace pas toujours au même endroit. Il faut donc pouvoir préciser.

def deplacer_crayon(x,y):
    up()
    goto(x,y)
    down()

C'est donc l'usage des () de la fonction : elles permettent de préciser des entrées.

Pour rendre le programme encore plus clair, on documente la fonction, c'est à dire que l'on ajoute un commentaire juste après la signature.

def deplacer_crayon(x,y):
    """
    Déplace le crayon levé.
    x, y: coordonnées de la destination
    """
    up()
    goto(x,y)
    down()

from turtle import * # import de la bibliothèque turtle

# définitions fonctions
def tracer_carre(taille):
    """
    Trace un carré
    taille: dimension du côté
    """
    for i in range(4):
        forward(taille)
        left(90)

def deplacer_crayon(x,y):
    """
    Déplace le crayon levé.
    x, y: coordonnées de la destination
    """
    up()
    goto(x,y)
    down()

# initialisation
speed(5)
shape("turtle")
pencolor("red")
pensize(4)
setheading(0)

# tracé
deplacer_crayon(0,0)
tracer_carre(100)
deplacer_crayon(20,20)
tracer_carre(100)
deplacer_crayon(40,40)
tracer_carre(100)
#tracé terminé
exitonclick()

voilà qui est plus simple à comprendre !

Inspirez-vous de ce qui précède pour tracer la figure ci-dessous. Les carrés ont des tailles de 100, 80, 60 et 40.

Cette figure est composées de carrés. Leur taille va diminuant en étant divisée à chaque fois par le nombre d'or : $\varphi = \frac{1 + \sqrt{5}}{2}$.

J'ai numéroté les carré pour que ce soit plus clair.

Écrivez une fonction tracer_polygone_regulier(n, taille) dont on donne le nombre de côtés n (au moins 3) et la taille du côté.