Vidéo 17 : L’instruction if/else

\(\newcommand{\ds}{\displaystyle}\) \(\newcommand{\Frac}{\ds\frac}\) \(\renewcommand{\r}{\mathbb{ R}}\) \(\newcommand{\C}{\mathbb{ C}}\) \(\newcommand{\n}{\mathbb{ N}}\) \(\newcommand{\z}{\mathbb{ Z}}\) \(\newcommand{\Q}{\mathbb{ Q}}\) \(\newcommand{\N}{\mathbb{ N}}\) \(\newcommand{\n}{\mathbb{ N}}\) \(\newcommand{\ol}{\overline}\) \(\newcommand{\abs}[1]{\left| \,{#1} \right|}\) \(\newcommand{\pv}{\;;\;}\) \(\newcommand{\ens}[1]{\left\{ {#1} \right\}}\) \(\newcommand{\mens}[1]{\setminus\left\{ {#1} \right\}}\) \(\newcommand{\Par}[1]{\left({#1}\right)}\)

Vidéo 17 : L’instruction if/else

Instruction if/else

L’instruction if/else permet de coder un schéma du type

si … alors … sinon …

Soit un programme qui à partir d’un nombre \(\mathtt{x}\) affiche plus si \(\mathtt{x > 42}\) et qui sinon affiche moins. En Python, cela donne :

if_else.py

1
2
3
4
5
6
7
x=10
if x > 42:
    print("plus")
else:
    print("moins")

print("FIN")
8
9
moins
FIN
  • Ligne 2 : comme dans une instruction if simple, la condition est testée

  • Lignes 2-5 : l’instruction if/else

  • Ligne 4 : si la condition N’est PAS vérifiée,

    • la partie sous le if N’est PAS examinée
    • le bloc sous le else est exécuté
  • Ligne 7 : l’exécution du programme continue alors normalement.

Inversement, si la condition suivant le if est vérifiée la partie else n’est pas examinée :

if_else_bis.py

1
2
3
4
5
6
7
x=50
if x > 42:
    print( "plus")
else:
    print("moins")

print("FIN")
8
9
plus
FIN
  • Ligne 2 : ici, la condition x > 42 est vérifiée donc seule la ligne 3 est examinée
  • Lignes 4-5 : ces lignes ne sont pas examinées durant l’exécution.

Le mot else doit être compris comme sinon. Une instruction if/else propose une alternative. Ainsi, le programme if_else.py doit être compris comme codant l’alternative suivante :

  • si \(\mathtt{x > 42 }\) alors le programme affiche plus
  • sinon, le programme affiche moins

Le mot else est un mot-clé du langage Python. Dans le cadre d’une instruction if/else, le mot else doit toujours être suivi du signe deux-points (:). Sous la ligne figurant else se trouve un bloc indenté. La ligne contenant else ainsi que le bloc indenté forment ce qu’on appelle une clause else de l’instruction if. Le corps de la clause else est le bloc indenté. Ce corps peut être constitué de n’importe quel type d’instructions.

C’est une erreur courante chez les débutants de vouloir placer une condition après le else, par exemple else x<42. Une clause else est toujours suivie immédiatement du signe :.

Quand on écrit une instruction if/else, prendre garde que le mot if et le mot else soient à la même indentation et rien d’autre ne doit être à la même indentation entre if et else.

Le terme d’instruction if/else est un abus de langage. En fait, il s’agit d’une instruction if contenant une clause else.

Indentation d’une instruction composée avec clause

Une instruction composée est constituée au minimum d’un en-tête et d’un corps, typiquement :

1
2
3
if 42 > 421:
    print("hello!")
    print("OK!")
  • Ligne 1 : l’en-tête
  • Lignes 2-3 : corps composé de deux instructions.

Mais, certaines instructions composées peuvent être composées aussi d’une, voire de plusieurs, « clauses ».

Le cas suivant d’une instruction if/else est typique de la structure générale d’une instruction composée avec clause:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
x=50
if x > 42:
    print( "plus")
    if x > 100:
        print("plus plus")
else:
    print(x)
    print("moins")

print("FIN")
  • Lignes 2-8 : une instruction if
  • Lignes 6-8 : une clause else de l’instruction if
  • Lignes 3-5 : le corps de l’instruction if. Ce corps est constitué de deux instructions : une instruction simple (ligne 3) et une instruction composée (if, lignes 4-5)
  • Lignes 6-8 : le corps de la clause else.

Les clauses font partie de l’instruction composée. Chaque clause contient un en-tête placé sur une seule ligne et qui se termine toujours par le signe deux-points. Le signe deux-points est suivi d’un ensemble d’instructions appelé « corps » de la clause.

Règles d’indentation

Soit une instruction composée contenant une ou plusieurs clauses. Alors,

  • l’en-tête de l’instruction composée et chacune des clauses sont sur des lignes différentes et à la même indentation ;
  • les instructions figurant dans le corps de l’instruction composée sont à la même indentation ;
  • les instructions figurant dans le corps de n’importe quelle clause de l’instruction composée sont à la même indentation ;
  • le corps de l’instruction composée ou de l’une de ses clauses peut contenir des instructions de n’importe quel type, simples ou composées. Ces instructions suivent les règles générales de l’indentation en Python.

Le plus grand, le plus petit

On donne deux entiers \(\mathtt{a}\) et \(\mathtt{b}\). Ecrire un code qui calcule le plus petit et le plus grand des deux entiers \(\mathtt{a}\) et \(\mathtt{b}\). Les valeurs calculées seront placées dans des variables mini et maxi.

Solution

Il suffit de comparer les deux nombres pour savoir qui est mini et qui est maxi, d’où le code :

a = 42
b = 17

if a < b:
    mini=a
    maxi=b
else:
    mini=b
    maxi=a

print(a, b)
print("mini =", mini, "maxi =", maxi)
42 17
mini = 17 maxi = 42

Il est intéressant de remarquer que des variables mini et maxi sont créées à la fin du code sans que pour autant on ait en tout début de code (comme pour a et b) une définition par affectation de ces variables : dans le corps d’une instruction if on peut placer n’importe quel type d’instruction qu’on aurait placée en début de code.

On pouvait aussi écrire le code suivant qui évite le else :

a = 42
b= 17

maxi=a
mini=b

if a < b:
    mini=a
    maxi=b

print(a, b)
print("mini =", mini, "maxi =", maxi)

Nombre intermédiaire

On donne trois entiers \(a\), \(b\) et \(c\), par exemple \(a=42\), \(b=100\) et \(c=10\). On demande de déterminer et d’afficher le nombre qui est encadré par les deux autres. Dans l’exemple précédent, on a \(c\leq a\leq b\) donc le nombre demandé est \(a=42\).

Dans un deuxième temps, on pourra essayer de chercher un code qui minimise le nombre de comparaisons.