Vidéo 16 : L’instruction if

\(\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 16 : L’instruction if

Instruction if

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

si … alors …

Illustration

On veut coder un programme qui :

  • définit une variable x référant un entier,

  • affiche la valeur de x,

  • teste si x est strictement négatif et, si c’est le cas, affiche :

    • le message : x est négatif,
    • l’opposé de x (c’est-à-dire -x),

  • se termine en affichant le message Fin du programme.

Voilà ce que pourrait afficher le programme si la variable x dans le code-source vaut 10 :

-10
x est négatif
10
Fin du programme

Le programme sera intitulé instruction_if.py.

Implémentation en Python

Le programme instruction_if.py doit afficher un message et un nombre si une certaine condition est vérifiée. Pour cela, en Python, on utilise

  • une instruction if pour exprimer l’idée de condition si … alors …
  • un booléen pour exprimer la condition si.

Le problème posé admet la solution suivante :

instruction_if1.py

1
2
3
4
5
6
7
8
x = -10
print(x)

if x < 0:
    print("x est négatif")
    print(-x)

print("Fin du programme")

 9
10
11
12
-10
x est négatif
10
Fin du programme

Examinons maintenant le même code que instruction_if1.py où on a remplacé x = -10 par x = 42 en ligne 1 :

instruction_if2.py

1
2
3
4
5
6
7
8
x = 42
print(x)

if x < 0:
    print("x est négatif")
    print(-x)

print("Fin du programme")

 9
10
42
Fin du programme

L’édition d’une instruction if

On reprend le code ci-dessus :

instruction_if1.py

1
2
3
4
5
6
7
8
x = -10
print(x)

if x < 0:
    print("x est négatif")
    print(-x)

print("Fin du programme")

  • Lignes 4-6 : une instruction conditionnelle. Elle utilise le mot-clé if.

  • Ligne 4 : la condition testée est x < 0. Cette condition est toujours suivie du séparateur : (deux-points). La ligne qui s’étend du mot-clé if jusqu’au séparateur s’appelle l”en-tête de l’instruction if.

  • Lignes 5-6 : le corps de l’instruction if est le bloc situé aux lignes 5 et 6. Ce corps, la plupart du temps :

    • commence sous l’en-tête (il faut donc sauter une ligne) ;
    • est indenté par rapport à l’en-tête.

Exécution d’une instruction if

On reprend les codes ci-dessus :

instruction_if1.py

1
2
3
4
5
6
7
8
x = -10
print(x)

if x < 0:
    print("x est négatif")
    print(-x)

print("Fin du programme")

ainsi que

instruction_if2.py

1
2
3
4
5
6
7
8
x = 42
print(x)

if x < 0:
    print("x est négatif")
    print(-x)

print("Fin du programme")

  • Ligne 1 : très souvent, la condition de l’instruction if dépend d’une variable définie avant l’instruction if. Ici, la variable s’appelle x.

  • Ligne 4 : lorsque l’exécution du code arrive face à une condition if, la condition if est testée : vaut-elle True ? vaut-elle False ?

  • Lignes 5-6 :

    • si la condition vaut True (cf. instruction_if1.py), les instructions du corps de if sont exécutées
    • si la condition vaut False (cf. instruction_if2.py), les instructions du corps de if sont ignorées et l’exécution passe directement à la suite du code (ligne 8)

  • Ligne 8 : Une fois l’instruction if exécutée, l’exécution continue normalement.

Indentation intelligente des éditeurs

L’indentation d’une ligne code est marquée par un décalage vertical par rapport à la marge.

Dans la plupart des éditeurs, l’indentation est intelligente et constante :

  • intelligente car l’éditeur, en fonction de la présence du séparateur deux-points en fin de ligne, sait s’il doit, ou non, indenter la ligne suivante
  • constante car chaque passage à la ligne dans un bloc fait commencer la ligne à la même indentation que la précédente.

Soit le code suivant :

1
2
3
4
5
6
7
x = -100

if x < 0:
    print("x est negatif")
    print(-x)

print "Fin du programme"
  • Lignes 1 et 3 : pas d’indentation.
  • Ligne 4 : le début de ligne est indenté automatiquement.
  • Ligne 5 : le début de ligne est positionné automatiquement.
  • Ligne 6 : l’éditeur indente automatiquement le début de ligne et le codeur doit retirer lui-même l’indentation avec la touche Retour-Arrière.

Dans un éditeur adapté au langage Python, le programmeur n’a pas à gérer l’indentation de son code. En fait, ce que l’éditeur ne gère pas automatiquement, c’est la fin de l’indentation, autrement dit le moment où le bloc indenté se termine et qu’il faut diminuer l’indentation, ce qui dépend seulement du souhait du programmeur et que l’éditeur ne peut deviner.

Instructions if imbriquées

Le corps d’une instruction if peut être n’importe quelle instruction, en particulier une nouvelle instruction if.

Exemple

1
2
3
4
5
n = 3000
if n % 10 == 0:
    q = n // 10
    if q % 10 == 0:
        print("n est multiple de 100")

6
n est multiple de 100

Une instruction if est une instruction multiple. Le corps d’une instruction if peut être de taille quelconque et contenir tout type d’instructions.

Indentation d’une instruction composée

Soit le code d’une instruction if typique :

1
2
3
4
5
6
7
x = -100

if x < 0:
    print("x est negatif")
    print(-x)

print("Fin du programme")

Le programme ci-dessus contient trois instructions :

  • Ligne 1 : une instruction simple (affectation)
  • Lignes 3-5 : l’instruction if qui est une instruction composée.
  • Ligne 7 : une instruction simple (instruction d’affichage)

Ces trois instructions sont indentées avec la même valeur d’indentation qui est de 0 espace par rapport à la marge gauche du code.

On observe toutefois (lignes 4-5) que certaines lignes du code sont indentées.

Règles fondamentales de l’indentation

L’instruction if (lignes 3-5) est une instruction composée et son indentation doit respecter deux règles fondamentales :

  • Règle 1 : si le corps de l’instruction if est placé sur plusieurs lignes, ce corps est indenté par rapport à la ligne d’en-tête ;
  • Règle 2 : toutes les instructions dans le corps de l’instruction sont à la même indentation. Autrement dit, si par exemple la 1ère instruction du corps de l’instruction if (ici ligne 4) est indentée de 4 espaces par rapport à l’en-tête, toutes les autres instructions du corps de l’instruction if, par exemple ici la ligne 5, seront aussi indentées de 4 espaces par rapport à l’en-tête.

Non-respect des règles

Règle 1

Le code ci-dessous ne respecte pas la règle 1 :

1
2
3
4
5
6
7
x = -100

if x < 0:
print("x est negatif")
print(-x)

print("Fin du programme")
  • Lignes 4-5 : ces deux lignes devraient être indentées.

et l’exécution va générer un message d’erreur d’indentation au niveau de la ligne 4 :

 7
 8
 9
10
  File "if_erreur1_indentation.py", line 4
    print("x est negatif")
        ^
IndentationError: expected an indented block
  • Lignes 8-11 : Le message d’erreur.
  • Lignes 8 : Le nom du fichier-source et le numéro de ligne à l’origine de l’erreur sont fournis.
  • Lignes 9-10 : La ligne à l’origine de l’erreur et un marqueur (le signe circonflexe ^) signalant où l’erreur est rencontré dans la ligne.
  • Ligne 11 : Le type d’erreur, ici IndentationError (erreur d’indentation) et une description sommaire de la raison de cette erreur.

Règle 2

Le code ci-dessous ne respecte pas la règle 2 :

if_erreur2_indentation.py

1
2
3
4
5
6
7
x = -100

if x < 0:
     print("x est negatif")
    print(-x)

print("Fin du programme")
  • Lignes 4-5 : ces deux lignes devraient être à un même niveau d’indentation. Or la ligne 4 est indentée de 5 espaces et la ligne suivante de 4 espaces au lieu de 5.

et l’exécution va générer un message d’erreur d’indentation au niveau de la ligne 5:

if_erreur2_indentation.py

 7
 8
 9
10
  File "if_erreur2_indentation.py", line 5
    print(-x)
            ^
IndentationError: unindent does not match any outer indentation level
  • Ligne 10 : Le message explique que l’indentation n’est pas uniforme. L’indentation de la ligne 4 est acceptée pas celle de la ligne 5.

Noter que la règle d’indentation s’applique aussi à une instruction if emboîtée :

1
2
3
4
5
n = 3000
if n % 10 == 0:
    q = n // 10
    if q % 10 == 0:
        print("n est multiple de 100")
  • Lignes 4-5 : instruction composée emboîtée.

Régler un montant avec des coupures de même valeur

On vous donne la valeur b d’un billet en euros, par exemple b = 10 et un montant m, nombre entier représentant un montant en euros à régler, par exemple, m = 8181. Déterminer le nombre minimum N de billets de b euros pour être en mesure de régler le montant m.

Par exemple,

  • si b = 10 et m = 8181 alors N = 819
  • si b = 10 et m = 800 alors N = 80

Solution

Il y a deux cas selon que le montant peut être réglé de manière exacte avec des billets de montant b. Par exemple, si b=10 et m=8181, le montant ne peut être réglé de manière exacte (sans rendu de monnaie). Le nombre exact de billets est clairement 819 car avec 818 billets on peut régler jusqu’à 8180 euros (et il manque 1 euro) et avec un billet de plus, on peut régler le montant (et il restera neuf euros) ; ce dernier nombre (819) est une unité de plus que le quotient entier de m par b. D’où le code :

b= 10
m=8181
N=m//b
r=m%b
if r!=0:
    N=N +1
print("b = ", b, "m =", m, "->", N)
print("->", N)

print()

b= 10
m=800
N=m//b
r=m%b
if r!=0:
    N=N +1
print("b = ", b, "m =", m, "->", N)
print("->", N)

b =  10 m = 8181 -> 819
-> 819

b =  10 m = 800 -> 80
-> 80
  • Lignes 16 et 17 : s’il est possible de payer exactement la somme m avec des billets b alors la condition ligne 16 est fausse et c’est N qui donne la réponse attendue.

On peut aussi utiliser else:

if m%b!=0:
    N=m//b +1
else:
    N=m//b