On souhaite réaliser cette figure avec trois fois le même carré de côté 100, avec un petit décalage chaque fois.

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

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

# tracé
up()
goto(0,0)
down()
for i in range(4): # premier carré
    forward(100)
    left(90)
up()
goto(20,20)
down()
for i in range(4): # deuxième carré
    forward(100)
    left(90)
up()
goto(40,40)
down()
for i in range(4): # troisième carré
    forward(100)
    left(90)
# tracé terminé
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 !