Booléens et tests en Python

Un booléen est une variable qui peut avoir deux états possibles, généralement vrai ou faux, en langage Python True ou False.

Les booléens sont très utiles pour des tests.

On parle aussi de variable booléenne, c'est-à-dire une variable qui contient un booléen.

Le type d'un booléen en Python est bool.

Les tests en Python :

Voilà quelques opérateurs :

Pour tester la comparaison et l'égalité ensemble de deux éléments a et b : a <= b renvoie True si a ≤ b et False sinon.

Les tests précédents fonctionnent avec des entiers ou des flottants mais aussi avec des chaînes de caractères (type str) ; c'est l'ordre lexicographique qui s'applique alors : on compare les premiers caractères des deux chaînes, puis les seconds si les premiers sont égaux, et ainsi de suite. De plus, les majuscules sont considérées avec les minuscules.

Voici des exemples de tels tests : 

>>>12 <= 13
True 
>>>2+2 == 4.0
True 
>>>6 != 3**2
True 
>>>"un" < "deux"        # "u" après "d" dans l'ordre lexicographique
False 
>>>"150" < "90"         # comparaison des caractères, non des nombres 
True

Exécuter le code suivant en le recopiant dans un Jupyter : 

velocity = 50
print("Est-il vrai que velocity = 50 ?")
print(velocity == 50)
type(velocity == 50)

Si besoin, vous pouvez utiliser le site Trinket.

  1. Quel rôle différent ont velocity = 50 de la ligne 1 et velocity == 50 de la ligne 3 du code précédent ?

  2. Comment s'écrit en langage Python le type booléen ?

Code de déblocage de la correction :

Attention à ne pas confondre :

Plus généralement, ne pas confondre les termes instruction et expression.

Les opérateurs et et ou sont très utiles en programmation en len liant deux affirmations booléennes ou deux variables booléennes.

L'opérateur et est noté en langage Python and.

L'opérateur ou est noté en langage Python or.

Deviner avant de lancer les codes suivants quel sera le booléen résultat. Ensuite, vérifiez en exécutant chaque code.

  1. b = 56
print(b != 5 and b != 6)                            
  2. b = 56
print(b <= 5 or b >= 6)                            
  3. b = 56
print(b == 50+6 or b >= 6)                             
  4. b = 56
print(b >= 6 and b < 50+6)

Code de déblocage de la correction :

exercice de renforcement

Attention à ne pas confondre :

Dans un jeu vidéo un personnage dispose d'un niveau d'encombrement (poids porté en kg) qui dépend de sa force et de son équipement. Il se trouve que votre personnage est ralenti s'il est encombré, c'est-à-dire si son encombrement dépasse sa force multiplié par 10.

  1. Proposer une fonction est_pas_encombre qui prend en paramètre deux nombres entiers encombrement et force, correspondant à sa force et à son encombrement, qui renvoie un booléen : True si ce nombre entier encombrement est compris entre 0 et 10 x force, False dans les autres cas.

  2. Rajouter une précondition pour tester que la variable encombrement est bien un nombre entier.

Code de déblocage de la correction :

exercice de renforcement

En Python, il y a une évaluation séquentielle (dite aussi évaluation passive) des expressions contenant des and ou des or :

  1. Exécuter la fonction suivante avec $n=4$ puis $n=5$ : 

    def de_l_or(n):
    return (n < 5) or (erreur > zut)

    Expliquer ce qu'il se passe.

  2. Que se passe-t-il si l'ordre des deux conditions n < 5 et (erreur > zut) est inversée ?

Code de déblocage de la correction :

Dans le langage courant, le mot "OU" et "ET" sont symétriques :

Par contre, dans le langage Python, du fait de l'évaluation séquentielle, il n'y pas de symétrie avec les or et and :

L'opérateur NON de négation s'écrit en langage Python not.
Si A est un booléen, alors l'expression not A prend la valeur contraire de celle de A. 

>>>not 2+2 == 4
False 
>>>not 'abc' > 'bac'
True

  1. Deviner avant d'exécuter le code ce que va afficher le script suivant :

    mot = "AbcDE"
print('a' in mot and 'f' not in mot)

  2. Vérifier en exécutant le code.

  3. Deviner avant d'exécuter le code ce que va afficher le script suivant :

    mot = "AbcDE"
print('a' in mot or 'C' not in mot)

  4. Vérifier en exécutant le code.

Code de déblocage de la correction :

exercice de renforcement

Voici un exercice à faire en autonomie pour tester votre maîtrise des bases sur les booléens.
Cet exercice est issu du site collaboratif de la forge.

Cliquer sur ce lien pour accéder à l'exercice.

if ... else

Structure alternative

En pseudo-code (avec de nombreuses variantes pour identifier les blocs d'instructions), la structure conditionnelle s'écrit :

1 if condition then
2 	bloc 1
3 else
4 	bloc 2

la structure conditionnelle en Python

En langage Python, la structure conditionnelle s'écrit :

if condition :
    instruction(s) à effectuer dans la cas où la condition est remplie
else :
    instruction(s) à effectuer dans la cas contraire
            
life = float(input("Entrer le nombre de points de vie de votre personnage  : "))
if life > 0:
    print("Votre personnage vit, le nombre de ses points de vie est : " + str(life))
else :
    print("Votre personnage est mort :'( ")

Qu'affiche le programme de l'exemple dans chacun des cas suivants :

  1. Avec life = 8 ?

  2. Avec life = -6 ?

  3. Avec life = 0 ?

  4. Avec life = "52" ?

Vous pouvez tester directement le programme précédent sur Pythontutor.
En appuyant sur la touche Next>, vous visualiserez le fait que l'interpréteur du code ne traite que l'instruction du if ou celle du else suivant si la condition est remplie ou non.

Code de déblocage de la correction :

exercice de renforcement

Il est possible d'imbriquer plusieurs instructions conditionnelles ensemble.

On peut modifier l'exemple précédent ainsi en trois cas distinctions par imbrication de deux instructions conditionnelles : 

a = float(input("Entrer un nombre réel : "))
if a > 0:
    print("Vous avez entré un nombre strictement positif", a)
else: # ici, on est dans le cas où a <= 0
    if a == 0:
        print("Vous avez entré un nombre nul", a)
    else: # ici, on est dans le cas où a <= 0 et a != 0 donc où a < 0
        print("Vous avez entré un nombre négatif", a)

Pour gérer le niveau d'un personnage qui dépend du nombre de points d'expérience, on veut programmer en Python l'algorithme suivant :

Soit xp la variable stockant le nombre de points d'expérience du personnage.

  • Si xp est inférieur à 1000 afficher "niveau débutant",

  • Si xp est compris entre 1000 et 10000 afficher "niveau confirmé",

  • Sinon afficher "niveau expert".

La traduction littérale de l'énoncé conduit au code interne à la fonction suivante : 

def obtenir_niveau(xp: int) -> None:
    if xp < 1000:
        print("Débutant")
    if 1000 <= xp and xp <= 10000:
        print("Confirmé")  
    else:
        print("Expert")

  1. Quel est l'affichage obtenu pour obtenir_niveau(100) ?

  2. Expliquer pourquoi l'affichage ne correspond pas à ce qui est attendu.

  3. Modifier légèrement le code Python, sans modifier les conditions présentes, afin de le corriger.

Code de déblocage de la correction :

Structure avec elif

Plutôt que d'imbriquer plusieurs instructions conditionnelles lorsqu'il y a plus de deux cas, il est possible d'utiliser la structure elif , qui est la contraction de else if.

if condition1:
	instruction(s)
elif condition2:
	instruction(s)
elif condition3:
	instruction(s)
else:
	instruction(s)

Votre personnage dispose de potions de soins lui rendant 20 points de vie

La fonction suivante permet d'appliquer des dégâts à un personnage et à tester si le personnage peut continuer à jouer. La fonction damage renvoie les points restants ainsi que le nombre de potions dans le cas où le joueur peut continuer à jouer. 

def damage(life, damage, nb_potion):
    life = life - damage
    if life > 0:
        return life, nb_potion  
    elif nb_potion > 0:
        life = life + 20
        nb_potion = nb_potion - 1
        return life , nb_potion
    else:
        print("Game Over :'(")

Un club sportif formant des jeunes de moins de 14 ans vous a demandé de créer un programme pour informer les familles de la catégorie à laquelle appartiendra leur enfant en fonction de leur âge.

Le club sportif vous a donné ces informations :

  1. Écrire une procédure categorie qui :

    • Demande l’âge d’un enfant à l’utilisateur,

    • informe l'utilisateur de la catégorie de l'enfant,

    • ne renvoie rien.

  2. Rajouter des préconditions afin que d'assurer le bon fonctionnement de cette fonction.

Code de déblocage de la correction :

exercice de renforcement

  1. Réaliser une fonction main.
    Cette fonction, sans argument, réalise les actions suivantes :

    • La procédure commence par afficher dans un menu quatre actions différentes avec la valeur à saisir pour sélectionner chacune d'elle. (cf. partie entre *************** dans l'exemple ci-dessous)

    • La procédure demande ensuite à l'utilisateur son choix parmi les quatre possibilités. (cf. partie entre *************** et ===============> dans l'exemple ci-dessous)

    • La procédure affiche enfin le nom de l'action choisie par l'utilisateur. (cf. partie après ===============> dans l'exemple ci-dessous)

    Exemple d'affichages successivement obtenus dans le cas où l'utilisateur tape 2 :

    ***************
Menu
Jump, tapez 1
Forward, tapez 2
Back, tapez 3
wait, tapez 4
***************
Votre choix : 2
===============>
Votre choix : Forward

  2. Tester la fonction main en n'oubliant aucun cas possible.

Code de déblocage de la correction :

exercice de renforcement

  1. Proposer une fonction, nommée mini2 qui prend comme arguments deux nombres entiers a et b et qui renvoie la plus petite valeur de ces deux nombres.

    2. Code de déblocage de la correction :

  2. Proposer une fonction, nommée mini4, qui :

    • prend comme arguments quatre nombres entiers a, b, c et d,

    • fait appel plusieurs fois à la fonction mini2,

    • renvoie le plus petit nombre des 4.

    Commencer par trouver quelle stratégie vous mettriez en oeuvre pour trouver le minimum de 6, 4, 3 et 5 si vous ne pouviez avoir en tête que deux nombres mais que vous pouviez écrire des résultats intermédiaires sur une feuille.

    3. Code de déblocage de la correction :

exercice de renforcement

Une année n’est bissextile, c'est-à-dire qu'elle dure 366 jours, que dans l’un des deux cas suivants :

  1. Proposer une fonction est_bissextile qui prend en argument une année de type nombre entier et qui renvoie un booléen précisant si l'année est bissextile ou non.

    Indication : le code a % b renvoie le reste de la division euclidienne de $a$ par $b$.
    Exemple : 15 % 6 renvoie 3 car $15 = 6 \times 2 + 3$.

    2. Code de déblocage de la correction :

  2. Utiliser judicieusement and et or afin d'obtenir un script utilisant seulement un if.

Code de déblocage de la correction :

Il est important de comprendre comment on peut limiter les instructions return dans une structure conditionnelle :

Comme souvent en informatique, plusieurs codes sont possibles pour un même programme.
Considérons par exemple les 3 fonctions ci-dessous qui renvoie une chaîne de caractères si un nombre est "négatif", "positif et pair" ou "positif et impair".

Méthode 1 : on peut insérer un return dans chaque bloc conditionnel : 

def informer1(n: int) -> str:
    if n < 0:
        return "négatif"
    elif n % 2 == 0:
        return "positif et pair"
    else:
        return "positif et impair"

Cette méthode peut paraître la plus naturelle lorsque l'on commence la programmation.

Méthode 2 : on peut supprimer les else puisqu'une fonction prend fin dès la réalisation d'une instruction avec return : 

def informer2(n: int) -> str:
    if n < 0:
        return "négatif"
    if n % 2 == 0:
        return "positif et pair"
    return "positif et impair"

Cette méthode permet de condenser le code mais l'ordre des cas à tester ne peut pas être inversé.

Méthode 3 : avoir un unique return après des blocs conditionnels où une affectation de variable à lieu. 

def informer3(n: int) -> str:
    if n < 0:
        resultat = "négatif"
    elif n % 2 ==0:
        resultat = "positif et pair"
    else:
        resultat = "positif et impair"
    return resultat

Ce dernier cas est parfois privilégié en programmation pour faciliter le contrôle et prouver le bon fonctionnement de la fonction.
Il nécessite de spécifier alors entièrement la structure conditionnelle if ... elif ...else.

Voici un exercice pour apprendre à éviter une erreur habituelle en programmation.

On considère un jeu de dé où on perd si le dé vaut 1 ou 2 mais on gagne sinon.

La traduction littérale de on perd si le dé vaut 1 ou 2 conduit à la fonction (procédure en fait) suivante : 

def jeu(de: int) -> None:
    if de == 1 or 2:  # le dé vaut 1 ou 2
        print("Perdu !")
    else:
        print("Gagné !")

  1. Testez la fonction jeu pour les six entiers compris entre 1 et 6.
    Quel affichage obtenez-vous toujours ?

  2. On considère la fonction suivante où seule l'expression booléen est modifiée : 

    def jeu2(de: int) -> None:
    if de == 1 or de == 2:  # le dé vaut 1 ou le dé vaut 2
        print("Perdu !")
    else:
        print("Gagné !"")

    Vérifier que la procédure jeu2 convient.

Code de déblocage de la correction :

Même si le langage Python est très permissif, faites en sorte d'avoir toujours deux booléens entre les opérateurs logiques or et and afin d'avoir un code au comportement bien prévisible pour vous.

En Python, il est possible d'avoir des objets de différents types de part et d'autre des opérateurs and et or. Ces opérateurs renvoient alors le dernier argument évalué.

Ainsi, quel que soit le type d'une variable truc, on a les évaluations suivantes :

Ainsi dans l'exercice précédent de == 1 or 2 est évalué à 2.
Comme de plus en Python if nombre: est considéré comme if True: si nombre est différent de 0, la condition de if de == 1 or 2: sera toujours considérée comme vraie ; d'où l'affichage constant à Perdu ! obtenu avec la procédure jeu dans l'exercice précédent.

Voici un exercice à faire en autonomie pour tester votre maîtrise des bases sur les booléens et les instructions conditionnelles.
Cet exercice est issu du site collaboratif de la forge.
Dans cet exercice vous travaillerez sur la validation de mot de passe. D'ailleurs, n'hésitez pas à consulter l'explication qui explique comment avoir un mot de passe fort ainsi que le lien qui aboutit à une illustration amusante qui illustre quelle démarche est préférable pour créer des mots de passe à la fort et facilement mémorisables.
En cas de difficultés, n'hésitez à basculer vers la "Version à compléter" où vous aurez à gérer les différentes variables booléennes proposées.

Cliquer sur ce lien pour accéder à l'exercice.

Écriture condensée

Il est possible d'écrire sous forme condensée sur une ligne certaines instructions conditionnelles.

Pour cela, au lieu d'avoir :

if condition 1:
    Traitement des instructions du bloc 1 
else:
    Traitement des instructions du bloc 2

on réécrit sous la forme suivante l'instruction :

Traitement des instructions du bloc 1 if condition 1 else Traitement des instructions du bloc 2

Voici une fonction qui renvoie le maximum de deux entiers $a$ et $b$ grâce à une instruction conditionnelle : 

def maxi(a: int, b: int) -> int:
    if a > b : 
        return a 
    else: 
        return b

On peut réécrire en une ligne l'instruction conditionnelle ; ainsi cette fonction devient : 

def maxi(a: int, b: int) -> int:
    return a if (a > b) else b

Réécrire la fonction mini2 de l'exercice déjà traité (lien direct) en écrivant sur une seule ligne l'instruction conditionnelle.

Code de déblocage de la correction :

L'objectif de la programmation n'est pas d'écrire de manière la plus condensée possible un programme car il est souvent préférable d'écrire un code correct et facilement compréhensible par d'autres codeurs.

try ... except

Partie qui sera sûrement utile lors des projets mais qui est hors programme.

L'exécution d'un programme peut provoquer une erreur. Lorsque c'est le cas, l'exécution s'arrête immédiatement et l'interpréteur Python affiche une trace d'erreur.

En python, on peut gérer ces erreurs éventuelles d'exécution.

Une erreur lors de l'exécution d'un programme est appelée une exception.

On dit que l'interpréteur lève une exception lorsqu'il rencontre une erreur dans le programme, l'arrête en renvoyant un message d'erreur.

Imaginons un algorithme où une division par un nombre réel saisi $a$ est nécessaire : 

a = int(input("valeur de a = "))
b = 10
print("b/a =", b/a)

Si besoin, vous pouvez utiliser le site Trinket.

Si vous exécutez ce programme avec $a=0$, l'interpréteur rencontre un problème : ici l'erreur $10/0$ (erreur appelée exception).

L'interpréteur arrête le programme et renvoie un message d'erreur : il lève une exception. Le message peut prendre différentes formes :

Dans tous les cas, apparaît le type de l'exception : ZeroDivisionError.

On retrouve ainsi qu'il est nécessaire de tester si le nombre $a$ saisi est nul ou non afin d'éviter que le programme s'arrête du fait d'une division par 0.

Pour cela, vous connaissez déjà le mot-clé assert.

  1. Exécuter le script suivant dans un Jupyter avec différentes valeurs de $a$, dont 0 :

    a = int(input("valeur de a = "))
assert a != 0, "erreur, le nombre saisi est nul"
b = 10
print("b/a =", b/a)

  2. Est-ce que le programme se termine dans tous les cas ?

Code de déblocage de la correction :

Si vous exécuter le script précédent en saisissant $a=0$, l'interpréteur teste la condition de l'assert puis affiche le message d'erreur saisi par le programmeur afin de faciliter la compréhension de l'erreur puis mais force l'arrêt de l'exécution du programme.

Or, mettre fin à un programme de manière forcer peut être très gênant lorsque ce programme fait partie d'un programme plus conséquent.

Pour gérer les erreurs tout évitant l'arrêt du programme, il suffit d'utiliser la commande:

try:
    notre interpréteur essaie
except:
    ce que notre interpréteur fait si le précédent essai ne passe pas.

  1. Exécuter le script suivant dans un Jupyter avec différentes valeurs de $a$, dont 0 :

    a = int(input("valeur de a = "))
b = 10
try:
    print("b/a =", b/a)
except:
    print('il faut entrer un nombre non nul !')

  2. Est-ce que le programme se termine dans tous les cas ?

Code de déblocage de la correction :

Explication :

Dans le cas où $a=0$, arrivé à la ligne 4, l'interpréteur commence par essayer d'évaluer le quotient $b/a$.

Comme il n'est pas possible d'effectuer une telle division, son essai échoue, l'interpréteur arrête le bloc try sans s'occuper du print("b/a =", b/a) pour passer directement au bloc lié à except : il affiche donc le texte de la ligne 6. Ainsi, l'erreur de diviser par 0 ne conduit pas à un arrêt non désiré du programme.

  1. Créer une procédure votre_age qui demande à l'utilisateur son année de naissance, qui affiche son âge (approximatif car la date précise n'est pas prise en compte) mais qui ne renvoie rien.

  2. Tester votre procédure avec, entre autres, 2005 puis "deux mille cinq".

  3. Améliorer la procédure votre_age en utilisant la structure try ... except afin que le programme ne cesse pas si autre chose qu'un entier est saisi et en faisant en sorte qu'un message d'erreur adéquat apparaisse ; par exemple "Veuillez saisir un nombre entier."

Code de déblocage de la correction :

Il est possible aussi de préciser quel type d'exception (=type d'erreur) doit être levé à chaque fois, pour cela, il suffit de préciser après le mot-clé except le nom du type d'erreur : ZeroDivisionError, ValueError, ...

  1. Exécuter le script suivant dans un Jupyter avec différentes valeurs de $a$, dont 0 et 1.0 :

    try:
    a = int(input("valeur de a = "))
    b = 10
    print("b/a =", b/a)
except ValueError:
    print("Erreur : la valeur saisie n'est pas un entier valide")
except ZeroDivisionError:
    print('Erreur : il faut entrer un nombre non nul pour ne pas diviser par zéro !')

  2. Est-ce que le programme se termine dans tous les cas ?

  3. Que signifie le type d'erreur ValueError ?

  4. Quel est l'intérêt ici de préciser deux except ?

Code de déblocage de la correction :

  1. Proposer une fonction age qui :

    • demande l'âge de l'utilisateur,

    • teste que la saisie est bien convertible en un nombre entier,

    • renvoie l'âge ou 0 en cas d'erreur de saisie.

  2. Tester la fonction, en particulier en saisissant "seize" et 16.

Code de déblocage de la correction :

Il est parfois utile de créer une exception sans que l'interpréteur ne rencontre une erreur.

Le mot-clé raise permet de créer une exception sans que l'interpréteur ne rencontre une erreur.

Voici une procédure qui demande à l'utilisateur son âge puis lève une exception si la personne est mineure sans rien retourner. 

def pour_majeur() -> None:
    try:
        age = int(input("Veuillez saisir votre âge"))  
        if age < 18: 
            print("Vous devez être majeur.e !")
            raise ValueError
        else:  
            print("âge valide")  
    except :  
        print("âge non valide !")

Tester la procédure pour_majeur de l'exemple précédent avec différents saisies, en particulier "seize", 16, 18 ou 19.5.

Code de déblocage de la correction :

  1. Proposer une fonction contient_e qui prend une chaîne de caractères en argument et qui renvoie si cette chaîne contient la lettre $e$ grâce à un booléen.

  2. Modifier le programme précédent afin qu'il gère l'erreur du type de saisie, erreur appelée TypeError.
    Par exemple si l'utilisateur entre un nombre à la place d'une chaîne de caractères en renvoyant le message suivant : 

    Erreur : donner comme argument une chaîne de caractères.

    Il existe plusieurs façons de s'assurer que l'argument est bien une chaîne de caractères, essayez la commande : 

    isinstance(ma_chaine, str)

    isinstance(268, str) renvoie False tandis que isinstance("Mon texte !", str) renvoie True.

Code de déblocage de la correction :

La PEP 8 qui est une convention regroupant les différents conseils pour bien écrire un code en Python recommande d'utiliser la fonction isinstance(variable, type) pour tester un type de variable : 

if isinstance(objet, int):  # est correct et à privilégier à long terme
if type(objet) is int:      # est moins bien
if type(objet) == int:      # est à éviter à long terme

Exercices de renforcement

Sur les booléens

  1. Proposer une fonction eau_liquide qui prend en paramètre un nombre entier tempe (qui modélise la température de l'eau) et qui renvoie un booléen : True si ce nombre entier est compris entre 0 et 100, False dans les autres cas.

  2. Rajouter une précondition pour tester que la saisie est bien un nombre entier.

Cliquer pour afficher la solution 
# Correction du 1/
def eau_liquide(tempe:int) -> bool:
    return tempe >=0 and tempe <= 100

# Correction du 2/
def eau_liquide(tempe:int) -> bool:
    assert type(tempe) == int,"L'argument donné à la fonction doit être un nombre entier"
    return tempe >=0 and tempe <= 100

Pour télécharger le code de cette correction : cliquer ici.

Deviner avant de lancer les codes suivants quel sera le booléen résultat. Ensuite, vérifier en exécutant chaque code.

  1. a = 6
print(a >= 5 and a < 6)
  2. b = -1
print(b <= 0 or b >= 5)
Cliquer pour afficher la solution 
a = 6
print(a >= 5 and a < 6)
# Faux car la deuxième condition est fausse : Vrai and Faux donne Faux.

b = -1
print(b <= 0 or b >= 5)
# Vrai car la première condition est vraie : Vrai ou Faux donne Vrai tout comme Vrai ou Vrai donne Vrai

Pour télécharger le code de cette correction : cliquer ici.

  1. Deviner avant d'exécuter le code ce que va afficher le script suivant ?

    mot = "Nous sommes heureux et heureuses de faire NSI !"
print('a' not in mot and 'i' in mot)

  2. Vérifier en exécutant le code.

  3. Deviner avant d'exécuter le code ce que va afficher le script suivant ?

    mot = "Quelle chance que de pouvoir aller au lycée !"
print('N' not in mot or 'é' in mot)

  4. Vérifier en exécutant le code.

Cliquer pour afficher la solution 
mot = "Nous sommes heureux et heureuses de faire NSI !"
print('a' not in mot and 'i' in mot)
# La condition 'a' not in mot est fausse,
# La condition 'I' in mot est fausse,
# Faux et Faux donne Faux donc l'affichage est False.

# Pourtant nous sommes tous et toutes heureux.ses de faire NSI !

mot = "Quelle chance que de pouvoir aller au lycée !"
print('N' in mot or 'é' in mot)
# La condition 'N' in mot est fausse,
# La condition ''é' in mot est vraie,
# Faux ou Vrai donne Vrai donc l'affichage est True.

# C'est vrai que l'école est une grande chance pour chacun.e !

Pour télécharger le code de cette correction : cliquer ici.

Sur if else voire elif

Proposer un algorithme qui :

Cliquer pour afficher la solution 
a=float(input("Entrer un nombre réel : "))
if a>=10 :
    print("Vous avez entré un nombre plus grand ou égal à 10 :",a)
else :
    print("Vous avez entré un nombre strictement plus petit que 10 :",a)

Pour télécharger le code de cette correction : cliquer ici.

Un théâtre pratique trois types de tarifs suivant le nombre de pièces regardées.

Écrire un programme qui :

Cliquer pour afficher la solution 
nb_pieces = int(input("Entrer le nombre de pièces que vous désirez allez voir : "))
if nb_pieces<3 :
    prix = nb_pieces * 15
elif nb_pieces<5 :      # Forcément le cas "nb_pieces<3" est traité dan sle if précédent, il n'est pas nécessaire de préciser ici "nb_pieces<5 and nb_pieces>2"
    prix = nb_pieces * 12
else :
    prix = nb_pieces * 10
print("Vous avez à payer",prix,"euros.")

Pour télécharger le code de cette correction : cliquer ici.

  1. Proposer une fonction etat_eau qui prend en paramètre un nombre entier tempe (qui modélise la température de l'eau en °C) et qui renvoie une chaîne de caractère : "solide" si ce nombre entier est négatif, "liquide" si la température est comprise entre 0 et 100 °C et "gazeux" si la température dépasse 100 °C.

  2. Est-il possible d'écrire cette fonction etat_eau sans utiliser un else ni trois if ?

  3. Rajouter deux préconditions pour tester que la saisie est bien un nombre entier et que la température est possible, c'est-à-dire supérieure ou égale à -273°C.

Cliquer pour afficher la solution 
# Correction possible du 1/
def etat_eau(tempe: int) -> str:
    if tempe<0:
        return "solide"
    elif tempe>=0 and tempe<=100:
        return "liquide"
    else:
        return "gazeux"

# Correction possible du 2/
def etat_eau(tempe: int) -> str:
    if tempe<0:
        return "solide"
    elif tempe>=0 and tempe<=100:
        return "liquide"
    return "gazeux"
# On peut supprimer le dernier else.
# En effet, dès qu'un return est appliqué dans une fonction, la suite du programme de cette fonction n'est pas pris en compte.
# Ainsi, les cas où la température est inférieure ou égale à 100°C sont pris en compte dans le if et le elif et le programme
# ne dépasse les lignes return "solide" ou return "gazeux".
# Si on n'est pas dans le cas d'une telle température (c'est-à-dire si tempe>100) alors automatiquement l'interpréteur
# considère la ligne suivant la fin du elif, donc affiche "gazeux".

# Correction possible du 3/
def etat_eau(tempe: int) -> str:
    assert type(tempe) == int,"Veuillez donner comme argument un nombre entier."
    assert tempe >= -237,"La température doit être au moins de -273 °C."
    if tempe<0:
        return "solide"
    elif tempe>=0 and tempe<=100:
        return "liquide"
    return "gazeux"

Pour télécharger le code de cette correction : cliquer ici.

    Vous êtes en charge de la programmation d'un distributeur automatique. Vous avez d'abord à gérer l'affichage du choix du consommateur.

  1. Réaliser une fonction choix.
    Cette fonction, sans argument, affiche dans un menu les quatre sélections possibles différentes, nommées Boissons, Gâteaux, Fruits, Légumes et une dernière qui permet de sortir du programme.
    Ensuite, la sélection effectuée par l'utilisateur est enfin affiché à l'écran.

    Exemple de trace d'exécution ; cas où l'utilisateur tape 3 :

    Menu
Boissons, tapez 1
Gâteaux, tapez 2
Fruits, tapez 3
Légumes, tapez 4
Quitter, tapez 5 ou autre chose
Votre choix : 3
Votre choix : Fruits

  2. Tester la fonction choix en n'oubliant aucun cas possible.

Cliquer pour afficher la solution

Avec une seule procédure : 

def choix():
    print("Menu")
    print("Boissons, tapez 1")
    print("Gâteaux, tapez 2")
    print("Fruits, tapez 3")
    print("Légumes, tapez 4")
    print("Quitter, tapez 5 ou autre chose")
    saisie = input("Votre choix : ")
    code = input("Votre choix : ")
    if choix == "1" :
        print("Votre choix : Boissons")
    elif choix == "2" :
        print("Votre choix : Gâteaux")
    elif choix == "3" :
        print("Votre choix : Fruits")
    elif choix == "4" :
        print("Votre choix : Légumes")
    else :
        print("Sortie du programme")

Avec des fonctions comme sous-programmes : 

# --------------------------------------
# fonctions en tant que sous-programmes :
# --------------------------------------
def saisir_choix()->str:
    """
    Fonction affichant les choix possible et
    renvoyant la saisie sous forme d'une chaîne de caractères
    """
    print("Menu")
    print("Boissons, tapez 1")
    print("Gâteaux, tapez 2")
    print("Fruits, tapez 3")
    print("Légumes, tapez 4")
    print("Quitter, tapez 5 ou autre chose")
    saisie = input("Votre choix : ")
    return saisie

def traiter_choix(choix: str) -> None:
    """
    Procédure prenant en paramètre une chaîne de caractère nommée choix,
    ne renvoyant rien mais affichant un texte explicitant le choix entrepris.
    """
    if choix == "1" :
        print("Votre choix : Boissons")
    elif choix == "2" :
        print("Votre choix : Gâteaux")
    elif choix == "3" :
        print("Votre choix : Fruits")
    elif choix == "4" :
        print("Votre choix : Légumes")
    else :
        print("Sortie du programme")
    return None

# ----------------------
# programme principal :
# ----------------------

code = saisir_choix()
traiter_choix(code)

Pour télécharger le code de cette correction : cliquer ici.

On suppose que vous disposez déjà des deux fonctions mini2 et mini4 programmées dans un exercice précédent (cf. lien direct)

Proposer une fonction, nommée mini4, qui :

Cliquer pour afficher la solution 
def mini2(a,b):
    if a>b:
        return b
    else:
        return a

def mini4(a,b,c,d):
    e=mini2(a,b)
    f=mini2(c,d)
    return mini2(e,f)

def mini8(a,b,c,d,e,f,g,h):
    i=mini4(a,b,c,d)
    j=mini4(e,f,g,h)
    return mini2(i,j)

Pour télécharger le code de cette correction : cliquer ici.

Deux derniers exercices de renforcement pour ceux ou celles qui en auraient le besoin

Écrire un programme qui :

Cliquer pour afficher la solution 
age = int(input("Quel est votre âge ?"))
if age<18:
    print("Vous êtes majeur.e.s")
else:
    print("Vous êtes mineur.e.s")

Pour télécharger le code de cette correction : cliquer ici.

Corrigé de cet exercice en vidéo accessible avec ce lien.

Un cinéma pratique trois types de tarifs pour deux personnes.

Écrire un programme qui :

Cliquer pour afficher la solution 
age1 = int(input("âge de la première personne :"))
age2 = int(input("âge de la deuxième personne :"))
if age1<18 and age2<18:
    prix = 7*2
elif age1>=18 and age2>=18:
    prix = 18
else:
    prix = 15
print("Le prix à payer est",prix)

Pour télécharger le code de cette correction : cliquer ici.

Corrigé de cet exercice en vidéo accessible avec ce lien.

QCM

Questions issues de la Banque Nationale de Sujets

Propriétaire des ressources ci-dessous : ministère de l'Éducation nationale et de la jeunesse, licence CC BY SA NC.

Voici une sélection de questions issues de la banque nationale de sujets, répondez à ces questions (attention, cette sélection n'est pas exhaustive).

On considère le code suivant : 

if x < 4:
    x = x + 3
else:
    x = x - 3

Quelle construction élémentaire peut-on identifier ?

Réponses :

A- une boucle non bornée

B- une structure conditionnelle

C- une boucle bornée

D- un appel de fonction

À quelle affectation sont équivalentes les instructions suivantes, où $a$, $b$ sont des variables entières et $c$ une variable booléenne ? 

if a == b:
    c = True
elif a > b+10:
    c = True
else:
    c = False

Réponses :

A- c = (a == b) or (a > b+10)

B- c = (a == b) and (a > b+10)

C- c = not(a == b)

D- c = not(a > b+10)

On exécute le script suivant : 

a, b = 10, 3
if a < 10:
    a, b = a+2, b+a

Quelle est la valeur de b à la fin de son exécution ?

Réponses :

A- 3

B- 12

C- 13

D- 15

Sachant que l'expression not(a or b) a la valeur True, quelles peuvent être les valeurs des variables booléennes a et b ?

Réponses :

A- True et True

B- False et True

C- True et False

D- False et False

Quelle est la valeur de la variable b à la fin de l'exécution du script suivant ? 

a = 2
b = 5
if a > 8:
    b = 10
elif a > 6:
    b = 3

Réponses :

A- 3

B- 5

C- 6

D- 10

Autres QCM

Les QCM suivants sont issus de https://genumsi.inria.fr.

(Auteur Nicolas Revéret)

On a saisi le code suivant : 

a = float( input("Saisir un nombre : "))
if a < 1:
    print("TIC")
elif a > 8.5:
    print("TAC")
else:
    print("TOE")

Quel message affiche l’ordinateur lorsque l'utilisateur saisit 8.5 ?

Réponses :

A- TIC

B- TAC

C- TOE

D- Le code n'affiche aucun message

(Auteur Christophe BEASSE)

On considère la fonction donnée ci-dessous : 

def mystere(a, b):
    reponse = 1
    if a == 0:
        if b == 0:
            reponse = 0
    return reponse

Quelles est est la valeur renvoyée par l'instruction mystere(0, 1) ?

Réponses :

A- 0

B- 1

C- True

D- False

Soit la chaîne de caractères : ch = "Pensif au bord de l'océan"

Quelle valeur prend l'expression :

"nsi" in ch

Réponses :

A- True

B- False

C- "nsi"

D- "Pensif au bord de l'océan"

(Auteur : Sylvie Genre)

On définit la fonction mystère suivante : 

def mystere(n):
    if n%3 == 0 or n%5 == 0:
        if n%3 == 0:
            resultat = 'A'
        else :
            resultat = 'B'
    else :
        if n%5 == 0:
            resultat = 'C'
        else:
            resultat = 'D'
    return resultat

Quelle est la valeur de mystere(10) ?

Réponses :

A- 'A'

B- 'B'

C- 'C'

D- 'D'

Savoir-faire et savoir

Remédiation

En cas de difficultés persistantes sur certaines notions de ce chapitre, vous pouvez essayer de retravailler ces notions sur le site futurecoder de la forge.
Les pages liées aux "Structures conditionnelles `if`" et aux "Opérateurs booléens" sont celles le plus en lien avec le chapitre.
Certaines parties comme "Instructions sur plusieurs lignes" seront des nouveautés.

Sitographie

Pour prolonger sur la structure try except.


Licence Creative Commons
Les différents auteurs mettent l'ensemble du site à disposition selon les termes de la licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International

▲