S’adapter au contexte: les instructions conditionnelles

Contenu

S’adapter au contexte: les instructions conditionnelles#

Motivation : rôle des structures de contrôle#

Indication

Rappel

Nous avons vu que les instructions d’un programme sont exécutées de manière séquentielle (les unes après les autres), dans l’ordre où elles sont données, comme dans l’exemple suivant.

Exemple

debut()
droite()
avance()
prend()
gauche()
avance()
pose()
droite()
avance()
gauche()
avance()
avance()
droite()
ouvre()

Cependant, on a souvent besoin de rompre cette exécution séquentielle :

Soit pour s”adapter au contexte :
Soit pour répéter des instructions :

Pour cela, nous avons besoin des structures de contrôle. Dans cette feuille, nous allons explorer comment s’adapter au contexte avec les instructions conditionnelles. Ultérieurement, nous verrons comment répéter des instructions.

Instructions conditionnelles#

Introduction#

Le principe général est que, en fonction d’une condition, on va exécuter ou non certaines instructions. Voyons cela sur le premier labyrinthe ci-dessus que vous avez déjà croisé :

from laby.global_fr import *
Laby(niveau="3a")

---------------------------------------------------------------------------
ModuleNotFoundError                       Traceback (most recent call last)
Cell In[1], line 1
----> 1 from laby.global_fr import *
      2 Laby(niveau="3a")

ModuleNotFoundError: No module named 'laby'

Exécutez plusieurs fois la cellule suivante :

debut()
droite()
avance()
gauche()

Vous aurez noté qu’une fois la fourmi arrivée à cet endroit du labyrinthe, elle fait, selon les cas, face à une grande toile d’araignée (mortelle!) ou une petite. Elle doit donc agir différemment selon ce contexte.

Si elle fait face à une grande toile d’araignée, elle doit faire demi-tour pour passer par l’autre côté du labyrinthe.
Sinon elle fait face à une petite toile d’araignée qu’elle peut traverser sans danger.

Voilà comment cela peut s’écrire :

Laby(niveau="3a")

debut()
droite()
avance()
gauche()

if regarde() == Toile:
    gauche()
    avance()
    avance()
    droite()
    avance()
    avance()
    droite()
    avance()
    gauche()
else:
    avance()
    avance()
    gauche()
    avance()
    droite()

ouvre()

Les instructions conditionnelles#

Nous allons maintenant introduire formellement les instructions conditionnelles, et tout d’abord spécifier comment regrouper plusieurs instructions ensemble comme ci-dessus (et comme apperçu précédemment avec les fonctions.; cela se fait en Python à l’aide de l’indentation :

Définition : Bloc d’instructions

Un bloc d’instructions (code block) est une suite d’une ou plusieurs instructions à exécuter successivement. Il est délimité par son indentation (par convention quatre espaces de plus que le code environnant) ainsi que par un “:” sur la ligne qui précède :

    ...:

        instruction 1
        instruction 2
        ...
        instruction n

    ...

Nous pouvons maintenant définir les instructions conditionnelles simples et alternatives.

Définition : Instruction conditionnelle simple : «si … alors …»

Syntaxe :

if condition:
    bloc d instructions

Sémantique

Évaluation de la condition
Si sa valeur est vraie, exécution du bloc d’instructions

Exemple

if regarde() == Toile:     # Au secours, fuyons!
    gauche()
    gauche()

Définition : Instruction conditionnelle alternative : «si … alors … sinon …»

Syntaxe

if condition:
    bloc d instructions 1
else:
    bloc d instructions 2

Sémantique

Évaluation de la condition
Si sa valeur est «Vrai», exécution du bloc d’instructions 1
Si sa valeur est «Faux», exécution du bloc d’instructions 2

Exemple

if regarde() == Toile:    # Au secours, fuyons!
    gauche()
    gauche()
else:                     # Tout va bien
    avance()

x = 3              # Les entrées
y = 5

if ( x > y ):
    maximum = x
    minimum = y
else:
    maximum = y
    minimum = x

minimum

maximum

Exercice

Essayez la fonction suivante. Que fait-elle ?

def mystere(a, b):
    if a > b:
        return a
    else:
        return b

mystere(1, 5)

mystere(-2, 4)

mystere(29, 8)

Solution

Cette fonction calcule le maximum de a et b : si a est supérieur à b, la fonction renvoie a, sinon, elle renvoie b.

Exercice

Dans cet exercice, vous allez utiliser la fonction max ci-dessous pour calculer le maximum de deux nombres, trois nombres et quatre nombres.

def max(a, b):
    if a > b:
        return a
    else:
        return b

n1 = -2
n2 = 6
n3 = 0
n4 = 7

### BEGIN SOLUTION
max(n1, n2)
### END SOLUTION

### BEGIN SOLUTION
max(n1, max(n2, n3))
### END SOLUTION

### BEGIN SOLUTION
max(n1, max(n2, max(n3, n4)))
### END SOLUTION

Rappel : Les exercices précédés d’un ♣ sont plus difficiles et facultatifs. Il n’est pas nécessaire de les maîtriser pour passer à la suite.

### BEGIN SOLUTION
def max4(a, b, c, d):
    return max(a, max(b, max(c, d)))
### END SOLUTION

### BEGIN SOLUTION
max4(n1, n2, n3, n4)
### END SOLUTION

Exercice

Complétez la fonction min ci-dessous.
Indication consultez l’exemple de la fonction max plus haut et adaptez le.

def min(a, b):
    ### BEGIN SOLUTION
    if ( a < b ):
        return a
    else:
        return b
    ### END SOLUTION

min(2,3)

### BEGIN SOLUTION
min(6, 0)
### END SOLUTION

min(5, 10) == 5

min(6, -2) == -2

min(-3, -4) == -4

min(5, min(-3, 8)) == -3

assert( min(5, 10) ==  5 )
assert( min(6, -2) == -2 )
assert( min(2,  2) ==  2 )

Exercice

Complétez la fonction abs ci-dessous qui calcule la valeur absolue d’un nombre :

def abs(a):
    ### BEGIN SOLUTION
    if ( a < 0 ):
        return -a
    else:
        return a
    ### END SOLUTION

### BEGIN SOLUTION
abs(-2.5)
### END SOLUTION

abs(-5.1) == 5.1

abs(2.3) == 2.3

abs(-3.4) == 3.4

assert abs( 0.0) == 0.0
assert abs( 2.3) == 2.3
assert abs(-3.4) == 3.4

Nous allons maintenant voir comment traiter des contextes avec plus de deux cas.

Définition : Instruction conditionnelle filée : «si … alors … sinon si … alors sinon …»

Syntaxe

if condition1:
    bloc d instructions 1
elif condition2:
    bloc d instructions 2
else:
    bloc d instructions 3

Sémantique

Le code ci-dessus est strictement équivalent à (mais plus lisible que) :

if condition1:
    bloc d instructions 1
else:
    if condition2:
        bloc d instructions 2
    else:
        bloc d instructions 3

Il peut y avoir autant de clauses elif que nécessaire.

Exercice

Complétez la fonction frais_de_livraison ci-dessous qui prend en paramètre une distance en kilomètres et renvoie le montant des frais de livraison en fonction de cette distance selon les règles suivantes :

Si la distance est inférieure ou égale à 5 km, les frais de livraison sont de 5 €.
Si la distance est comprise entre 5 km (exclus) et 20 km (inclus), les frais de livraison sont de 10 €.
Si la distance est supérieure à 20 km, les frais de livraison sont de 15 €.

def frais_de_livraison(distance):
    ### BEGIN SOLUTION
    if distance <= 5:
        return 5
    elif distance <= 20:
        return 10
    else:
        return 15
    ### END SOLUTION

assert frais_de_livraison(3) == 5
assert frais_de_livraison(10) == 10
assert frais_de_livraison(30) == 15

Conclusion#

Dans cette feuille, nous avons vu comment utiliser des instructions conditionnelles simples, alternatives ou filées pour adapter le comportement du programme en fonction du contexte, selon le nombre de cas à traiter.

Avant de passer à la suite, nous vous proposons quelques exercices d’entraînement et de révisions autocorrigés.

import glob
from jupylates import Exerciser
exercises = glob.glob('../Exercices/conditions/*.md')
Exerciser(exercises, lrs_url="../.lrs.json", mode="train")

Retourner à l’index