Skip to content

Définir des nouveaux mots

Tu sais créer une tortue, la faire tracer, et répéter un bloc avec une boucle. Maintenant, on va ajouter nos propres mots au langage : dessiner un carré en écrivant simplement carre(), comme si c'était une instruction fournie.

Cours ici, exercices sur Capytale

Cette page est le cours. Les exercices sont sur Capytale.

Ajouter un mot au langage : la fonction

Souviens-toi de la première séance : on avait inventé un langage avec un petit vocabulaire de mots-instructions (droite, gauche, répète…). La tortue aussi a son vocabulaire de base (forward, left…).

Dans notre langage inventé : le mot définir

Rappelle-toi le carré de l'exercice 9 (langage droite / gauche / haut / bas) :

répète 3 fois :
    droite
répète 3 fois :
    bas
répète 3 fois :
    gauche
répète 3 fois :
    haut

C'est pénible à écrire : à chaque côté, on répète le même motif, répète N fois : suivi d'une seule direction. Autant créer, pour chaque direction, un mot réglable par le nombre de cases, une bonne fois pour toutes.

C'est exactement ce qu'on fait en français. On ne dit pas « j'exprime la gaieté par un mouvement de la bouche, accompagné d'expirations saccadées plus ou moins bruyantes », on dit « je ris ». On a inventé le mot rire pour ne pas avoir à décrire l'action à chaque fois. Un mot, c'est un raccourci qu'on se donne une fois pour toutes, et rien n'empêche d'en inventer de nouveaux.

On ajoute une nouvelle construction à notre langage, définir NOM(réglage) :. Il faut bien distinguer deux étapes, qu'on confond souvent : définir un mot n'est pas l'utiliser.

1. Définir un mot, c'est écrire sa recette avec le vocabulaire qu'on connaît déjà (droite, répète…) :

définir repeter_droite(n) :
    répète n fois :
        droite

définir repeter_gauche(n) :
    répète n fois :
        gauche

À ce stade, rien ne se dessine. On a seulement enrichi le vocabulaire de deux nouveaux mots, repeter_droite et repeter_gauche, chacun réglable par un paramètre n.

2. Utiliser un mot, c'est l'employer dans une phrase du langage (un programme), exactement comme les mots de base :

repeter_droite(3)

C'est seulement à cet appel que le trait est réellement tracé, avec n = 3.

Étape Ce qu'on écrit Effet
Définir définir NOM(param) : puis le bloc indenté Rien ne se dessine : le vocabulaire s'enrichit d'un mot NOM, réglable par param
Utiliser (appeler) NOM(valeur) Le bloc s'exécute, avec param remplacé par valeur

À l'intérieur du bloc défini, n se comporte comme une valeur nommée : il vaut ce qu'on a mis entre parenthèses au moment de l'appel.

Exercice - Lire

Seuls repeter_droite et repeter_gauche ont été définis ci-dessus. Mais que dessine ce programme, en partant du coin en haut à gauche ?

repeter_droite(5)
repeter_bas(2)
repeter_gauche(5)
repeter_haut(2)
Correction

Un rectangle de 5 cases de large et 2 cases de haut. Le tracé revient à son point de départ.

Même sans avoir vu leur définition, on devine ce que font repeter_bas et repeter_haut : sur le modèle de repeter_droite et repeter_gauche, ce sont sûrement répète n fois : bas et répète n fois : haut.

Exercice - Écrire

Définis repeter_haut(n) et repeter_bas(n), comme tu les as devinés à l'exercice précédent. Puis récris le carré du début avec les quatre mots repeter_droite, repeter_bas, repeter_gauche, repeter_haut, sans utiliser répète toi-même.

Correction 
définir repeter_droite(n) :
    répète n fois :
        droite

définir repeter_gauche(n) :
    répète n fois :
        gauche

définir repeter_haut(n) :
    répète n fois :
        haut

définir repeter_bas(n) :
    répète n fois :
        bas

repeter_droite(3)
repeter_bas(3)
repeter_gauche(3)
repeter_haut(3)

Exercice - Écrire

En utilisant repeter_droite, repeter_bas, repeter_gauche et repeter_haut, définis un mot rectangle(largeur, hauteur) qui trace un rectangle de la largeur et de la hauteur données (en cases).

Correction 

définir rectangle(largeur, hauteur) :
    repeter_droite(largeur)
    repeter_bas(hauteur)
    repeter_gauche(largeur)
    repeter_haut(hauteur)

rectangle(5, 2)
rectangle a deux paramètres, largeur et hauteur, et sa recette réutilise les mots déjà définis : un mot peut en appeler d'autres, exactement comme il appelle les mots de base du langage.

Le même carré, en Python

La tortue a son vocabulaire de base (forward, left…). Ce vocabulaire n'a rien de magique : quelqu'un l'a inventé, exactement comme on vient d'inventer droite, répète ou définir. Python offre juste, en plus, un moyen d'ajouter nos propres mots à ce vocabulaire : le mot-clé def.

Si on dessine souvent des carrés, on aimerait un mot carre, comme s'il faisait partie du langage. C'est possible : une fonction permet d'ajouter un nouveau mot au vocabulaire, exactement comme définir dans notre langage inventé. On le définit une fois avec le mot-clé def, puis on s'en sert comme des autres mots :

from turtle import Turtle, done
hortense = Turtle()

def carre(t, longueur):
    for _ in range(4):
        t.forward(longueur)
        t.left(90)

carre(hortense, 100)
done()
  • def carre(t, longueur): définit un nouveau mot, carre, avec deux paramètres : t, quelle tortue doit dessiner, et longueur, la longueur du côté. Les lignes indentées en dessous disent ce qu'il fait, en parlant de t et longueur plutôt que d'une tortue ou d'une taille précises. Comme avec définir, rien ne se dessine à cette étape.
  • carre(hortense, 100) utilise ce mot (on dit qu'on l'appelle) en lui donnant hortense et 100 : c'est à cet appel que le carré est réellement dessiné, par hortense.

Désormais, carre fait partie de ton vocabulaire : tu peux l'appeler autant de fois que tu veux, pour n'importe quelle tortue et n'importe quelle longueur, exactement comme forward ou left. Tu fais grossir le langage à ta guise.

Réutiliser avec des valeurs différentes

À l'intérieur de la fonction, chaque paramètre se comporte comme une valeur nommée : t vaut la tortue donnée à l'appel, longueur vaut le nombre donné à l'appel. On peut donc rappeler carre avec des valeurs différentes, sans toucher à sa définition :

from turtle import Turtle, done
hortense = Turtle()

def carre(t, longueur):
    for _ in range(4):
        t.forward(longueur)
        t.left(90)

carre(hortense, 50)
carre(hortense, 150)
done()

carre(hortense, 50) appelle la fonction en donnant t = hortense et longueur = 50 ; carre(hortense, 150) la rappelle avec longueur = 150.

Une seule fonction, et autant de tortues et de longueurs qu'on veut. C'est tout l'intérêt du paramètre : une fonction générale plutôt qu'une fonction figée.

Se déplacer sans tracer

Sur le dessin ci-dessus, les deux carrés partent du même coin et se chevauchent. Pour les poser à des endroits différents, il faut pouvoir déplacer la tortue sans tracer, comme le lève / baisse du langage de tracé de la première séance. En Python :

hortense.penup()      # lever le crayon : les déplacements ne tracent plus
hortense.pendown()    # baisser le crayon : on trace de nouveau

Par exemple, un petit carré, un déplacement à vide, puis un grand carré :

from turtle import Turtle, done
hortense = Turtle()

def carre(t, longueur):
    for _ in range(4):
        t.forward(longueur)
        t.left(90)

carre(hortense, 50)
hortense.penup()
hortense.forward(120)
hortense.pendown()
carre(hortense, 50)
done()

Ce qu'on retient

  • Une fonction (def) ajoute un nouveau mot au langage : elle donne un nom à une suite d'instructions, réutilisable en l'appelant (carre(hortense, 100)), comme un mot de base. C'est l'équivalent Python du définir de notre langage inventé.
  • Un paramètre est un réglage donné à une fonction entre parenthèses : def carre(t, longueur):, puis carre(hortense, 100). Une fonction peut avoir plusieurs paramètres.
  • À l'intérieur de la fonction, chaque paramètre se comporte comme une valeur nommée : on peut rappeler la fonction avec des valeurs différentes, sans toucher à sa définition.
  • penup() / pendown() lèvent et baissent le crayon (comme lève / baisse), pour déplacer la tortue sans tracer.
  • Le cours est ici ; on s'entraîne sur Capytale.

Et ensuite

Une valeur nommée comme longueur ne vit que le temps d'un appel : dès que la fonction se termine, elle est oubliée. Comment retenir une valeur pour la réutiliser, et surtout la faire changer en cours de route, par exemple pour dessiner une spirale dont le côté grandit à chaque tour ? On va d'abord le découvrir par l'observation avec Silent Teacher, puis le mettre en œuvre.