Le « if … elif … else ».

Exemple.

Afin de mettre en place un système de caisses automatiques, le directeur d’un cinéma vous demande de coder un programme demandant au client son âge, et lui annonçant en retour le tarif appliqué :

• moins de 18 ans : 4€.
• sinon : 7€.

Algorithme en langage naturel, où a représente l’âge du client :

Si a < 18 :
    prix ← 4
Sinon :
    prix ← 7

Les conditions et le type booléen.

L’exemple précédent nous montre que nous allons avoir besoin de pouvoir tester si une condition (âge <= 18, par exemple) est vraie ou fausse : True ou False, en Python. Testons déjà ces quelques lignes :

Ceci nous explique l’intérêt du type booléen (boolean en anglais), introduit au chapitre précédent : une variable, que nous pouvons appeler « condition », stocke ainsi la valeur True ou False, et en fonction de cette valeur, le programme choisira la suite à donner.
Pour simplifier les choses, en première approche, nous n’avons pas donner de nom aux conditions « age <= 18 » et « AgePapa <= 18 ». Ce sont en réalité des variables de type booléen (vrai ou faux), comme le montre l’exemple ci-dessous :

Opérateurs de comparaison :

La condition testée peut contenir les opérateurs de comparaison suivants :

• x == y  : x est égal à y; en Python, le conditionnel se conjugue avec ==.
• x != y  : x est différent de y.
• x > y  : x est plus grand que y.
• x < y  : x est plus petit que y.
• x >= y  : x est plus grand que, ou égal à y.
• x <= y  : x est plus petit que, ou égal à y.

Attention : il ne faut pas confondre :

• l’opérateur de comparaison pour tester l’égalité de deux valeurs : = =.
• l’opérateur d’affectation utilisé pour affecter une valeur à une variable : =.

Le « if … elif … else » en Python.

Python exécute normalement les instructions de la première à la dernière ligne, sauf lorsqu’il rencontre une instruction conditionnelle comme l’instruction Si (ou, plus tard dans le cours, une boucle For ou While).

Une telle instruction va servir d’aiguillage et permettre au programme de suivre des chemins différents selon les circonstances (si plus ou moins de 18 ans ici).

Pour ce faire, nous devons disposer d’instructions capables de tester si une condition est vraie. Ici : tester si âge <= 18.

Exemple

Tester les instructions suivantes:

–> résultat ?

Remarques

• Lorsque vous finissez d’entrer la seconde ligne, après le caractère ‘ : ‘, Python réagit d’une nouvelle manière : l’invite >>> est remplacée par des espaces. Nous sommes rentrés dans un bloc d’instructions  »if » et Python attend la suite. Notons que la ligne suivante est indentée (c’est-à-dire en retrait) par rapport à la précédente (4 espaces).
  L’environnement IDLE s’avère très pratique en plaçant lui-même ces 4 espaces lors du retour à la ligne après  » :  ».
  Pour sortir de ce bloc d’instructions, il nous faudra appuyer sur la touche Retour arrière (en anglais backspace) du clavier.
• L’expression placée entre parenthèses est ce que appellerons désormais une condition. Si la condition est vraie, alors l’instruction indentée après le ‘ : ‘ est exécutée. Si la condition est fausse, rien ne se passe (ou encore le programme passe à la suite, s’il y a une suite).
• Notons que la condition a été placée entre parenthèses pour améliorer la lisibilité, mais que celles-ci ne sont pas indispensables.
• Dans le cas où la condition n’est pas satisfaite, nous pouvons programmer une exécution alternative à l’aide de l’instruction else ( »sinon », en anglais), dans laquelle le programme doit choisir entre deux possibilités :
• Nous pouvons obtenir plus encore d’alternatives avec l’instruction elif (contraction de  » else if  ») :

Exercice 9

Afin de mettre en place un système de caisses automatiques, le directeur d’un cinéma vous demande de coder un programme demandant au client son âge, et lui annonçant en retour le tarif appliqué :

• moins de 18 ans : 4€.
• 18 – 25 ans  : 5€.
• sinon  : 7€.

Aide

lors de la saisie par l’utilisateur de son âge, le programme stocke celui-ci dans une variable de type chaîne de caractères. Pour pouvoir comparer l’âge à 18 ou 25, il va falloir commencer par le convertir en nombre (→ a = int(a) ).
Même souci lors de l’affichage final avec une phrase : re-convertir a en texte : str(a).

age=int(input("Quel est ton âge?"))
if age<18 :
    print ("tu es agé(s)s de "+str(age)+" ans. Ta place te coute 4 Euros.")
elif age <=25 :
    print ("tu es agé(s)s de "+str(age)+" ans. Ta place te coute 5 Euros.")
else :
    print ("tu es agé(s)s de "+str(age)+" ans. Ta place te coute 7 Euros.")

Le rôle fondamental de l’indentation dans le langage Python.

Dans de nombreux langages, il faut terminer chaque ligne d’instruction par un caractère spécial (souvent un point-virgule). En python, c’est le retour à la ligne qui joue ce rôle.
De même, dans de nombreux langages, les blocs d’instructions tels que les if ou encore les boucles while et for doivent être délimités (dans Algobox : DEBUT SI … FIN SI, DEBUT POUR …FIN POUR ; en Java ou C++ : ce sont les accolades qui jouent ce rôle).
Cela permet d’écrire des programmes sans se préoccuper de l’indentation ou des sauts de lignes, mais conduit à des programmes difficiles à lire.
Avec Python, indentation et retours à la ligne jouent un rôle à part entière dans le sens du programme et il faut être très rigoureux sur ce point :

Testons par exemple les deux scripts suivants :

–> résultat :

–> résultat :
–> comment expliquez-vous la différence de comportement entre ces deux programmes ?

Exercice 10

Au baccalauréat, un candidat est :

• Refusé si sa moyenne est inférieure stricte à 8.
• Convoqué à l’oral de rattrapage si sa moyenne est comprise entre 8 et 10 (exclu).
• Admis avec mention passable si sa moyenne est comprise entre 10 et 12 (exclu).
• Admis avec mention assez bien si sa moyenne est comprise entre 12 et 14 (exclu).
• Admis avec mention bien si sa moyenne est comprise entre 14 et 16 (exclu).
• Admis avec mention très bien si sa moyenne est supérieure à 16.

Afin d’automatiser l’attribution des mentions, le Recteur d’académie vous commande un programme qui :

• demande à l’utilisateur la moyenne obtenue au baccalauréat.
• renvoie si le candidat est refusé, convoqué ou admis ainsi que la mention le cas échéant.

moyenne = float(input("Quel est la moyenne du candidat?"))
if moyenne<8 :
    print ("Candidat refusé.")
elif moyenne<10 :
    print ("Convoqué à l'oral de rattrapage.")
elif moyenne<12 :
    print ("Admis avec mention passable.")
elif moyenne<14 :
    print ("Admis avec mention assez bien.")
elif moyenne<16 :
    print ("Admis avec mention bien.")
else :
    print ("Admis avec mention très bien.")

Exercice 11

La grille ci-dessous est composée de 5 lignes et 5 colonnes.
Un bateau est situé en 4, 2 : colonne 4 et ligne 2, ou dans une case de votre choix.
Le joueur ne sait pas où se trouve le bateau et cherche à l’atteindre en tirant un boulet de canon.
Écrire un programme qui demande au joueur de choisir une colonne, puis une ligne et lui répond :

• Touché, si le joueur a trouvé la case du bateau.
• En vue, si le joueur a choisi une case sur la même ligne ou la même colonne que le bateau.
• A l’eau, sinon : le boulet tombe à l’eau.

Aide

1) Attention encore aux types (int ou str). Si l’on se sent à l’aise, on pourra maintenant gagner du temps avec une syntaxe plus ramassée :
col = int(input( 'Quelle est votre colonne ?'))
2) Le test du if peut composer plusieurs condition à vérifier :

• if (variable ==10) or (variable >=20) :
• if (variable1 ==2) and (variable2 ==5) :

3) Plutôt que d’écrire tout le programme d’un coup, au risque d’avoir du mal à trouver ses erreurs à la fin, on pourra réaliser des tests intermédiaires : par exemple, une fois testé si le bateau a été touché, lancer le programme pour vérifier que la partie déjà écrite fonctionne.

ligne = int(input("Ligne visée?"))
colonne = int(input("Colonne visée?"))
ligneBat = 2
colonneBat = 4
if (ligne == ligneBat) and (colonne == colonneBat):
    print("Touché")
elif (ligne == ligneBat) or (colonne == colonneBat):
    print("navire en vue")
else:
    print("A l'eau")

Méthodes élémentaires de programmation.

Ébauche fonctionnelle et ajout de couches successives.

Comme suggéré dans l’exercice 11, la construction d’un programme commence par une ébauche, que l’on teste, que l’on corrige, et qui fait déjà quelque-chose (dans l’exercice Touché – Coulé par exemple, nous avons commencé avec une ébauche testant uniquement si le bateau est touché).
A cette ébauche, on ajoute, couche par couche, de petites modifications et éléments supplémentaires, en testant et corrigeant au fur et à mesure les erreurs, afin d’avoir à chaque étape du processus un programme qui fonctionne.
Cette technique va permettre d’éviter de s’embarquer dans des impasses et surtout de trouver beaucoup plus facilement les erreurs (qui sont à rechercher dans des parties du code beaucoup plus restreintes que si nous attendions la fin du programme pour tout tester d’un coup).

Exercice 12

Écrire un programme 13_maximum.py qui prendra en entrée trois nombres réels a, b et c et qui renverra le maximum.

Contrainte d’efficacité

vous n’avez le droit qu’à deux if pour traiter cet exercice, commencer par compléter l’algorithme ci-contre.

a = int(input("nombre 1?"))
b = int(input("nombre 2?"))
c = int(input("nombre 3?"))
maximum = a
if b > maximum:
    maximum = b
if c > maximum:
    maximum = c
print("le maximum est : "+str(maximum))

Outiller son programme pour le débugger.

Lors des tests intermédiaires ou finaux d’un programme, une erreur est signalée par Python. Ou encore, un résultat du programme n’est pas celui que nous attendions.
Si nous ne parvenons pas à détecter où se trouve l’erreur, il sera judicieux d’insérer dans le programme des affichages de variables (print(…)), afin de mieux comprendre ce qui se passe durant l’exécution :

• le programme parvient-il à entrer dans un bloc d’instructions ‘ Si ‘, ou dans une boucle ?
• à quel moment telle ou telle variable commence-t-elle à prendre des valeurs inadéquates ? …

Exemple :

Le programme suivant est censé calculer la somme des carrés des n premiers nombres entiers.
1) Montrer que ce programme est erroné en le testant avec des valeurs bien choisies.
2) Outiller ce programme pour détecter l’erreur et la corriger

Indications :

1) Le programme fonctionne correctement avec n = 0, 1, 2. Vérifions-le avec n = 3.

2) Les variables beaucoup modifiées dans ce programme (donc en quelque sorte  »critiques ») sont : entier et somme.
Il paraît donc judicieux de les inspecter de plus près. Affichons ainsi les valeurs successives prises par « entier » à la fin de chaque tour de boucle while. Insérons donc un : « print(entier) » tout-à-fait à la fin de la boucle.
Que constatons-nous ? Corriger alors le programme.