Le python landais

Accueil

Plan du cours
Introduction
1. Installation
2. Variables
3. Types
4. If
5. While
6. For ... in
7. Fonctions
8. Interfaces graphiques
9. Listes
10. Interfaces graphiques 2
11. Traitement de l'image

Les exercices

Les QCM

Reeborg

Mini projets

Codage

L'ordinateur

Liens et ressources

Exécution conditionnelle « if … elif … else ».

Plan du chapitre :
1. Le « if … elif … else ».
..... a. Exemple.
..... b. Les conditions et le type booléen.
..... c. Le "if ...elif ... else" en Python.
2. Le rôle fondamental de l'indentation dans le langage Python.
3. Méthodes élémentaires de programmation.
..... a. Ébauche fonctionnelle et ajout de couches successives.
..... b. Outiller son programme pour le débugger.

1) Le « if … elif … else ».
a) Exemple.
Afin de mettre en place un système de caisses automatiques, le directeur du cinéma ''Atlantique Mega
Screen'' 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

b) 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 :

>>> age = 15
>>> age <= 18
True
>>> AgePapa = 42
>>> AgePapa <= 18
False

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 :

>>> age = 15
>>> condition = (age <= 18)
>>> print (condition)
True

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 : =.

--> Exercice 1.

c) Le "if ... elif ... else" en Pyhton.

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 :
Ouvrir l'interpréteur python (avec les >>>), et tester les
instructions suivantes :

>>> age = 16
>>> if ( age <= 17 ) :
print ('Vous êtes mineur')

--> 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 :

a = 25
if ( a <= 17 ) :
print ("Vous êtes mineur")
else :
print ("Vous êtes majeur")

--> résultat ?
Nous pouvons obtenir plus encore d'alternatives avec l'instruction elif (contraction de '' else if '') :

a = 16
if ( a <= 17 ) :
print ("Vous êtes mineur")
elif ( a == 18 ) :
print("Vous venez juste d'atteindre la majorité")
else :
print ("Vous êtes majeur")

--> résultat ?
Note : le même résultat aurait pu être obtenu avec le programme suivant :

a = 16
if ( a <= 17 ) :
print ("Vous êtes mineur")
if ( a == 18 ) :
print("Vous venez juste d'atteindre la majorité")
if ( a > 18 ) :
print ("Vous êtes majeur")

--> Quel est l'intérêt selon vous d'utiliser plutôt un elif et un else ?

--> Exercice 2.

2) 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 :

a = 3
if ( a > 10 ) :
a = a + 10
a = 2 * a
print (a)
--> résultat :

a = 3
if ( a > 10 ) :
a = a + 10
a = 2 * a
print (a)

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

--> QCM sur l'instruction "if".

--> Exercices 3 et 4.

3) Méthodes élémentaires de programmation.

a) Ébauche fonctionnelle et ajout de couches successives.
Comme suggéré dans l'exercice 3, 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 5.

b) 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.

n = input ("Jusqu'à quel entier n calculons-nous la somme des carrés ?")

n = int(n)
somme = 0
entier = 1
while ( entier <= n ) :
entier = entier**2
somme = somme + entier
entier = entier + 1 # Pour passer à l'entier suivant
print (somme)
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.

--> chapitre 5

Contact
CC BY-NC-SA 4.0