Skip to content

Retenir une valeur : la variable

Tu viens de découvrir avec Silent Teacher comment Python retient une valeur, et comment cette valeur peut changer. On va maintenant mettre des mots là-dessus, et s'en servir tout de suite pour dessiner quelque chose qu'on ne savait pas encore faire.

Cours ici, exercices sur Capytale

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

Un problème qu'on ne sait pas encore résoudre

On sait dessiner un carré : quatre côtés de même longueur. Mais comment dessiner une spirale carrée, dont le côté grandit à chaque tour ?

Avec ce qu'on connaît, on est coincé. forward(longueur) avec une longueur fixe donne toujours des côtés égaux. Pour agrandir, il faudrait écrire à la main forward(10), forward(20), forward(30)… : impossible à mettre dans une boucle, où chaque tour est identique. Il nous manque une valeur capable de changer d'un tour à l'autre. C'est exactement ce que Silent Teacher t'a fait observer.

Dans notre langage inventé : le mot mémoire

Reprenons notre langage (droite, répète, repeter_droite…). On lui ajoute une construction pour retenir une valeur sous un nom : mémoire NOM = valeur. Comme pour définir, deux gestes bien distincts.

1. Écrire dans la mémoire, c'est ranger une valeur sous un nom :

mémoire largeur = 3

Ça ne dessine rien : ça crée une mémoire nommée largeur qui contient 3.

2. Lire la mémoire, c'est employer ce nom à la place d'un nombre :

mémoire largeur = 3
repeter_droite(largeur)

Partout où largeur apparaît, le langage le remplace par la valeur rangée (3).

Étape Ce qu'on écrit Effet
Écrire mémoire NOM = valeur Rien ne se dessine : range valeur sous le nom NOM
Lire NOM, à la place d'un nombre Remplacé par la valeur actuellement rangée sous NOM

Une mémoire, c'est une boîte étiquetée. Le point important : on peut réécrire dedans, et la nouvelle valeur remplace l'ancienne, qui est perdue.

mémoire largeur = 3
mémoire largeur = 5

Après ces deux lignes, largeur vaut 5 : le 3 est écrasé. Le signe ici n'est pas un « égal » des maths ; il veut dire « range la valeur de droite dans la boîte de gauche ».

Ça permet un geste très utile : faire grandir une valeur, en rangeant dans la boîte son ancien contenu augmenté.

mémoire largeur = 1
mémoire largeur = largeur + 1

La deuxième ligne se lit : « range dans largeur la valeur de largeur, plus 1 ». On lit d'abord largeur (1), on ajoute 1 (2), et on réécrit le résultat dans largeur. Désormais largeur vaut 2.

Dans une boucle, ce geste trace un escalier dont les marches s'allongent (les mots repeter_droite et repeter_bas sont ceux de la page des fonctions) :

mémoire largeur = 1
répète 4 fois :
    repeter_droite(largeur)
    repeter_bas(1)
    mémoire largeur = largeur + 1

Exercice - Lire

Que vaut taille à la fin de ce programme ? (rien n'est dessiné, on suit juste la mémoire.)

mémoire taille = 10
mémoire taille = taille + 5
mémoire taille = taille + 5
Indice

Dessine la boîte taille sur ton cahier et efface son contenu à chaque ligne pour écrire le nouveau. Une boîte ne contient jamais deux valeurs à la fois.

Indice plus précis

Traite chaque ligne en trois temps, dans cet ordre : lire ce qu'il y a dans la boîte, calculer le résultat de droite, réécrire ce résultat dans la boîte. La ligne 2 se lit donc : « lis taille (10), ajoute 5 (15), range 15 dans taille ».

Avant d'ouvrir la correction

En une phrase, sur ton cahier : pourquoi taille = taille + 5 n'est-il pas une phrase impossible, alors qu'en mathématiques x = x + 5 n'a pas de solution ?

Correction

20. Départ à 10, puis +5 (15), puis +5 (20). Chaque ligne lit l'ancienne valeur, ajoute 5, et réécrit le résultat.

Sur la dernière question : le = de la mémoire ne compare pas les deux côtés, il range le côté droit dans la boîte de gauche. Les deux taille de la ligne ne désignent donc pas le même instant : celui de droite est l'ancienne valeur, celui de gauche la nouvelle.

Exercice - Écrire

Trace un escalier de 3 marches, où la première avance de 2 cases, la deuxième de 4, la troisième de 6 (chaque marche : avancer à droite, puis descendre d'une case). Utilise une mémoire qui grandit, sans écrire 2, 4, 6 à la main.

Indice

Les trois marches ne sont pas identiques, mais elles se ressemblent : à chaque fois, avancer puis descendre. Ce qui change d'une marche à l'autre, c'est une seule chose. Donne-lui un nom.

Indice plus précis

Il te faut deux ingrédients : une mémoire qui retient la largeur de la marche en cours, et une ligne dans le bloc répété qui la fait grandir de 2. Attention à l'endroit où tu places cette ligne : si elle est en dehors du bloc, elle ne s'exécute qu'une fois.

Avant d'ouvrir la correction

En une phrase, sur ton cahier : que se passerait-il si tu mettais mémoire largeur = 2 à l'intérieur du bloc répété ?

Correction 

mémoire largeur = 2
répète 3 fois :
    repeter_droite(largeur)
    repeter_bas(1)
    mémoire largeur = largeur + 2
La mémoire part de 2 et grandit de 2 à chaque tour : 2, puis 4, puis 6.

D'abord, voir une valeur : print

Avant de passer en Python, un problème pratique. La tortue montre son travail : le dessin s'affiche. Mais une valeur rangée en mémoire est invisible : rien à l'écran. Pour suivre ce que Python retient, il faut savoir afficher une valeur. C'est l'instruction print :

print("Bonjour")
print(3 + 4)

Ce programme affiche :

Bonjour
7

Regarde bien la différence entre les deux lignes : les guillemets changent tout.

  • Entre guillemets, c'est du texte, recopié tel quel : print("3 + 4") afficherait 3 + 4.
  • Sans guillemets, Python lit un calcul et affiche le résultat : print(3 + 4) affiche 7. Python connaît +, -, * (multiplier) et / (diviser).

C'est ce que Silent Teacher t'a fait deviner dans ses premières questions.

Pourquoi « print » ?

print veut dire imprimer en anglais. Aux débuts de l'informatique, il n'y avait pas d'écran : les résultats sortaient sur du papier. Les écrans sont arrivés ensuite, mais le mot est resté.

Le même mot, en Python : la variable

Rien de magique là non plus : Python a le même geste, mais le mot n'est pas mémoire, c'est le signe =. On dit qu'on affecte une valeur à une variable.

largeur = 3
hortense.forward(largeur)
  • largeur = 3 écrit dans la mémoire : crée la variable largeur avec la valeur 3. Rien ne se dessine.
  • hortense.forward(largeur) lit la variable : Python remplace largeur par 3.

Comme avec mémoire, réécrire remplace :

a = 4
a = 6
print(a)   # affiche 6

Le 4 est écrasé. Le = ne veut pas dire « égal » comme en maths ; il veut dire « range la valeur de droite dans la variable de gauche ». D'où le geste pour faire grandir une variable :

score = 10
score = score + 5   # score vaut maintenant 15

Et voici enfin la spirale qu'on ne savait pas dessiner : une variable longueur qu'on agrandit à chaque tour de boucle.

from turtle import Turtle, done
hortense = Turtle()

longueur = 10
for _ in range(20):
    hortense.forward(longueur)
    hortense.left(90)
    longueur = longueur + 10
done()

À chaque tour : la tortue avance de longueur, tourne d'un quart de tour, puis longueur grandit de 10. Le tour suivant trace un côté plus long : c'est ce qui creuse la spirale. Sans variable, impossible.

Le nom, c'est toi qui choisis

Le nom d'une variable, c'est le programmeur qui le choisit : Python s'en moque. Ces deux programmes font exactement la même chose :

longueur = 10

x = 10

Mais longueur se relit tout seul ; x, non : dans six mois, tu ne sauras plus ce que x contenait. Tu es libre du nom, mais choisis un nom parlant : il dit ce qu'il y a dans la boîte.

Des variables, tu en avais déjà croisé

Souviens-toi : à la page des fonctions, on disait qu'un paramètre (t, longueur…) se comporte comme une valeur nommée. C'était déjà une variable, mais un cas particulier : celle que Python remplit automatiquement, avec la valeur donnée à l'appel.

Et il y en a une autre, que tu écris depuis ton tout premier dessin :

hortense = Turtle()

Ce = est exactement le même que celui de largeur = 3 : il range dans la variable hortense la tortue qu'on vient de créer. « Donner un nom à la tortue », c'était déjà une affectation. Et tu remarques au passage qu'une variable ne contient pas forcément un nombre : ici, la boîte contient une tortue.

La nouveauté d'aujourd'hui, c'est que tu peux créer des variables toi-même, et écrire dedans quand tu veux, autant de fois que tu veux.

Ce qu'on retient

  • print(...) affiche une valeur : entre guillemets, du texte recopié tel quel ; sans guillemets, un calcul est effectué (+, -, *, /). C'est le seul moyen de voir ce que Python retient.
  • Une variable est une boîte en mémoire, étiquetée par un nom, où l'on retient une valeur pour la réutiliser ou la faire changer. C'est l'équivalent Python du mémoire de notre langage inventé.
  • Écrire (largeur = 3) ne dessine rien : ça range une valeur sous un nom. Lire (largeur), c'est utiliser ce nom à la place de sa valeur.
  • Le = range, il ne signifie pas « égal » : une nouvelle valeur écrase l'ancienne. D'où score = score + 5 pour faire grandir une variable.
  • Le nom est libre, mais on le choisit parlant.
  • Un paramètre de fonction est une variable particulière, remplie automatiquement à l'appel.
  • Une variable peut contenir autre chose qu'un nombre : hortense = Turtle() range une tortue dans la variable hortense.
  • Le cours est ici ; on s'entraîne sur Capytale.

Et ensuite

Tu sais répéter, et tu sais faire grandir une variable. À la prochaine séance, on combine les deux gestes pour compter, et on découvre que ce geste est si courant que Python lui a donné un raccourci.