Fiche à imprimer

En cours de programme, on a besoin de faire des calculs et de conserver les résultats pour un usage ultérieur. On stocke donc les résultats dans la mémoire de la machine.

Dans la mémoire, toutes les cases sont numérotées par une adresse qui permet à la machine de les identifier. Imaginez ce que cela pourrait donner :

écrire 72 à l'adresse 45465474
écrire 45 à l'adresse 78521365
ajouter le contenu à l'adresse 45465474 au contenu à l'adresse 78521365
afficher le contenu à l'adresse 78521365

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

• C'est peu lisible,
• la gestion de la mémoire est quelque chose de compliqué et il vaudrait mieux que l'on n'ait pas à choisir nous-mêmes les adresses des cases utilisées.

Au lieu de cela on préfère

écrire 72 dans x
écrire 45 dans y
ajouter le contenu de x au contenu de y
afficher le contenu de y

Et on laisse la machine décider automatiquement à quelle adresse se trouvera x et à quelle adresse se trouvera y. x et y sont alors de simples étiquettes qui évitent d'avoir à préciser une adresse.

Comme nous parlons de cases mémoires dont le contenu est susceptible de changer au gré du programme, on parle de variables.

Le pseudo-code précédent écrit en Python produit le code

x = 72
y = 45
y = x + y
print(y)

On a dit que x servait à éviter de mentionner l'adresse d'une case mémoire. Alors,

• x représente l'adresse ?
• x représente le contenu stocké à cette adresse ?

Eh bien un peu les deux, mais plutôt le second.

Quand on écrit y = x + y, on commence par le calcul à droite x + y, et il faut comprendre “le contenu de la mémoire x plus le contenu de la mémoire y”. Ensuite on exécute y = ce qui signifie que l'on écrit le résultat dans la mémoire y.

Quel est le contenu de a et b à l'issu des calculs suivants :

a = 2
b = a + 2
a = b * 2
b = b + a

a = 5
b = 7
a = b
b = a

a = 5
b = 7
c = a
a = b
b = c

a = 11
b = 19
b = a + b
a = b- a
b = b- a

Les 3 premiers se passent de commentaires.

• + addition
• - soustraction
• * multiplication
• / division

La puissance est notée ** ce qui diffère de beaucoup de langages – en général on rencontre plutôt ^ pour la puissance.

>>> 4**2
16

Les calculs sur les nombres entiers ont beaucoup d'applications et les deux opérateurs suivants sont particulièrement utiles.

• // division entière.
• % modulo, c'est à dire reste lors de la division entière

# 14 = 3*4 + 2 et donc :
>>> 14 // 4
3
>>> 15 % 4
2

Dans la grille ci-dessus, chaque ligne comporte 12 colonnes numérotées de 0 à 11. Les lignes sont numérotées à partir de 0. Les cases sont numérotées dans l'ordre de lecture à partir de 0 dans la case en haut à gauche.

On se demande comment passer facilement de la paire (ligne, colonne) au numéro de case.

Réfléchissez en pensant aux opérateurs // et %.

Exemples

1. Quels sont les numéros de ligne et colonne des cases 27, 43, 52, 3412 ?
2. Quel est le numéro de la case située ligne 25 et colonne 2 ?

Je souhaite calculer mon IMC. Je mesure 1 m 80, je pèse 80 kg. Je vais faire le calcul avec Python, un peu comme si j'utilisais une calculatrice.

>>> 80 / 1.8**2
24.691358024691358

Supposons que je veuille garder une trace de mon calcul, je peux l'enregistrer dans un programme.

# imc.py
80 / 1.8**2

En effet, je vous rappelle qu'en mode programme, le résultat d'un calcul ne s'affiche que si on le demande explicitement. Donc le résultat de 80/1.8**2 ne s'affichera pas.

On a donc l'idée d'ajouter la demande d'affichage :

# calcul de mon imc
print(80 / 1.8**2)

Cette fois cela fonctionne, mais le programme est très peu lisible. On ne sait pas à quoi correspondent 80 et 1.8 par exemple.

La première idée serait de remplir le programme de commentaires :

# imc.py
# Je mesure 1.8 m et je pèse 80 kg
# je calcule l'imc qui vaut taille/poids**2
print(80 / 1.8**2)

C'est bien de commenter mais pas n'importe comment. Les commentaires ne doivent pas servir à traduire un programme mal fichu. C'est une mauvaise idée.

taille = 1.8
poids = 80
imc = taille / poids**2
print(imc)

Voilà, nous avons obtenu un programme qui fait ce qu'on lui demande et qui est très lisible. On n'aura aucun mal à se rappeler ce que représentent les différents éléments même si on y revient 6 mois plus tard.

Je souhaite maintenant pouvoir réutiliser mon programme et même le diffuser à d'autres. Dans ce cas, un programme qui calcule toujours le même IMC n'a pas grand intérêt. Je veux un programme qui, au moment de l'utilisation, demande les grandeurs utiles et calcule le résultat correspondant.

# imc.py réutilisable
taille = float(input("Votre taille ? "))
poids = float(input("Votre poids ? "))
imc = taille / poids**2
print(imc)

La solution est tout à fait juste mais elle a un défaut : On a l'impression que le programme ne fait qu'une chose, calculer l'imc, mais en vérité il en fait trois !

1. lecture des données,
2. calcul de l'imc en fonction des données,
3. affichage du résultat.

Ici les 3 fonctions du programme sont plus ou moins confondues. Pourtant elles sont très différentes. La 1 et la 3 relève de l'interface homme - machine (IHM). Si nous voulions que notre calcul s'intègre dans un projet plus vaste, avec une interface graphique plus élégante, il faudrait plus clairement séparer les éléments.

Par exemple, supposons que ma mission est simplement de fournir de quoi calculer l'IMC. Ce sont d'autres membres de l'équipe qui s'occupent de fabriquer de beaux menus, de belles interfaces.

# imc.py intégré

def calc_imc(taille, poids):
    """
    taille: taille de l'individu en m
    poids: poids de l'individu en kg
    renvoi l'imc
    """
    imc = poids / taille**2
    return imc

Mon programme apparaît alors comme un simple module qui sera intégré dans un projet plus grand. Les autres membres de l'équipe n'auront qu'à écrire from imc import calc_imc, ce qui signifie : depuis le fichier imc.py, importer la fonction calc_imc. Ils pourront alors l'utiliser.