Exo If

Identification

Infoforall

11 - Exercices If


Tous les exercices sont corrigés.

Attention : lire une correction ne garantit pas de pouvoir refaire l'exercice. Comprendre et faire sont deux capacités différentes.

1 - Fonctions

01° Donner le contenu obtenu pour les différentes variables du programme principal.

1 2 3 4 5 6 7 8 9 10 11 12
# Déclaration des fonctions def f(a,b): r = a if a < b: r = b return r # Programme x = f(100, 200) y = f(50, 25) z = f(20, 50)

...CORRECTION 1-2...

La fonction f() renvoie la valeur maximale détectée entre a et b.

x = 200

y = 50

z = 50

02° A quelle fonction fA() ou fB() correspond première phrase ? A quelle fonction fB() ou fB() coorespond la deuxième phrase ?

  1. La preuve de correction de cette fonction sera plus facile à vérifier puisqu'elle ne possède qu'une zone de sortie.
  2. Le lecteur de cette fonction pourra plus facilement comprendre quand et quoi répondre mais il est plus difficile de vérifier que la réponse de la fonction est bien correcte car la fonction possède plusieurs portes de sortie.
1 2 3 4 5 6 7 8
def fA(note): if note > 13: app = "Bien" elif note < 9: app = "Insuffisant" else: app = "Moyen" return app
1 2 3 4 5 6 7
def fB(note): if note > 13: return "Bien" elif note < 9: return "Insuffisant" else: return "Moyen"

...CORRECTION 1-2...

La fonction A correspond à la phrase 1 : elle ne possède bien qu'une seule sortie et on pourra donc facilement rajouter un seul contrôle sur cette sortie.

La fonction B correspond à la phrase 2 : connaissant la note, il suffit de la lire pour savoir immédiatement qu'on a trouvé la bonne réponse à renvoyer. Le désavantage par contre est qu'il est plus compliqué de rajouter des instructions de vérification de correction de la réponse puisqu'elle possède trois zones de sorties.

03° Compléter la fonction trop_mechant() ci-dessous qui possède un paramètre note.

Voici son prototype :

1
def trop_mechant(note:int) -> int:

Elle doit renvoyer :

  • la note moins 2 si la note est supérieure à 10,
  • la note sans modification sinon.

Voici la déclaration à compléter, ainsi que des exemples d'utilisation :

1 2 3
def trop_mechant(note): "Renvoie une nouvelle valeur de la note modifiée par le prof trop méchant" pass
>>> trop_mechant(15) 13 >>> trop_mechant(11) 9 >>> trop_mechant(7) 7 >>> trop_mechant(2) 2

...CORRECTION...

1 2 3 4 5
def trop_mechant(note): "Renvoie une nouvelle valeur de la note modifiée par le prof trop méchant" if note > 10: note = note - 2 return note

Puisqu'on a pas besoin d'agir sur la note lorsqu'elle est déjà inférieure à 10, nous n'avons pas besoin de placer de else.

04° Compléter la fonction vraiment_trop_mechant() ci-dessous qui possède un paramètre note. ATTENTION : on ne veut qu'un seul return. Pas de version avec plusieurs sorties.

Voici son prototype :

1
def vraiment_trop_mechant(note:int) -> int:

Elle doit renvoyer :

  • la note moins 6 si la note est supérieure à 10,
  • la note moins 4 sinon.

Par contre, les notes pourraient devenir inférieures à 0. Avant envoi de la réponse, il faut modifier la note à 0 si elle est devenue négative.

Voici la déclaration à compléter, ainsi que des exemples d'utilisation :

1 2 3
def trop_mechant(note): "Renvoie une nouvelle valeur de la note modifiée par le prof trop méchant" pass
>>> vraiment_trop_mechant(15) 9 >>> vraiment_trop_mechant(11) 5 >>> vraiment_trop_mechant(7) 3 >>> vraiment_trop_mechant(2) 0

...CORRECTION...

1 2 3 4 5 6 7 8 9 10 11
def vraiment_trop_mechant(note): "Renvoie une nouvelle valeur de la note modifiée par le prof trop méchant" # Première modification if note > 10: note = note - 6 else: note = note - 4 # Vérification avant envoi if note < 0: note = 0 return note

05° Pour répondre à la question précédente, un élève propose cette version (car il n'a pas vraiment lu l'énoncé visiblement). QUESTION : quel est le "problème" créé par le fait que cette fonction utilise plusieurs return (à part le non respect de l'énoncé) ?

1 2 3 4 5 6 7 8 9 10 11 12
def vraiment_trop_mechant(note): "Renvoie une nouvelle valeur de la note modifiée par le prof trop méchant" # Première modification if note > 10: note = note - 6 return note else: note = note - 4 # Vérification avant envoi if note < 0: note = 0 return note

...CORRECTION...

Le problème survient sur la vérification des résultats renvoyés. S'il y a deux endroits où se trouve un return, cela veut dire qu'il fait placer des vérifications à deux endroits.

06° Compléter la fonction protocole() ci-dessous qui possède un paramètre url.

Voici son prototype :

1
def protocole(url:str) -> int:

Elle doit renvoyer :

  • 1 si le string url contient le string https://,
  • 2 si le string url contient le string http://,
  • 3 si le string url contient le string file://,
  • 0 sinon.

Il faudra juste utiliser le mot-clé in.

Voici la déclaration à compléter, ainsi que des exemples d'utilisation :

1 2
def protocole(url): pass
>>> protocole("https://www.infoforall.fr") 1 >>> protocole("http://doc.infoforall.fr") 2 >>> protocole("localhost") 0

...CORRECTION...

Première version (sans else, on donne la valeur par défaut au départ)

1 2 3 4 5 6 7 8 9
def protocole(url): rep = 0 if "https://" in url: rep = 1 elif "http://" in url: rep = 2 elif "file://" in url: rep = 3 return rep

Deuxième version : le else définit la valeur par défaut

1 2 3 4 5 6 7 8 9 10
def protocole(url): rep = 0 if "https://" in url: rep = 1 elif "http://" in url: rep = 2 elif "file://" in url: rep = 3 else: rep = 0 return rep

2 - Fonction booléenne

Attention, on veut des fonctions où on ne gère pas "à la main" l'envoi d'un True ou d'un False. A vous de placer directement une expression booléenne derrière le return de façon à forcer la fonction a renvoyé le résultat de cette expression.

07° Trouver un mot adapté à ce que fait la fonction nommée pour l'instant mystere().

La déclaration de la fonction :

1 2
def mystere(x): return len(x) == 0

Un exemple d'utilisation :

>>> mystere([4, 6]) False >>> mystere([]) True >>> mystere("Bonjour") False >>> mystere("") True

...CORRECTION...

La fonction renvoie True uniquement si la structure stockée dans le paramètre x est vide.

On pourrait donc la nommer estVide() ou estStructureVide() ou est_vide() ou est_structure_vide() ou tout autre nom explicite vis à vis de ce que réalise la fonction.

08° On vient de réaliser la fonction inconnue(). Examiner sa réponse et les exemples d'utilisation proposée. Dire comment il faut la nommer (une seule réponse vraiment correcte) :

  1. estStructureVide()
  2. estVide()
  3. estTableauVide()
  4. estStringVide()

La déclaration de la fonction :

1 2
def inconnue(x): return x == []

Un exemple d'utilisation :

>>> inconnue([4, 6]) False >>> inconnue([]) True >>> inconnue("Bonjour") False >>> inconnue("") False

...CORRECTION...

Cette fois, on voit que la fonction ne va renvoyer VRAI que si le paramètre est un tableau vide. La bonne réponse est donc C - estTableauVide()

09° Créer la fonction estAssezComplexe() qui va devoir vérifier qu'un mot de passe contient au moins 10 caractères.

La déclaration de la fonction :

1 2 3 4 5 6 7 8
def estAssezComplexe(mdp): '''Fonction qui renvoie True si le mot de passe est assez complexe :: param mdp(str) :: un mot de passe quelconque :: return (bool) :: True si mdp est complexe, False sinon ''' pass

Un exemple d'utilisation :

>>> estAssezComplexe("1234") False >>> estAssezComplexe("Bonjour") False >>> estAssezComplexe("BonjourATous!") True

...CORRECTION...

1 2 3 4 5 6 7 8
def estAssezComplexe(mdp): '''Fonction qui renvoie True si le mot de passe est assez complexe :: param mdp(str) :: un mot de passe quelconque :: return (bool) :: True si mdp est complexe, False sinon ''' return len(mdp) > 9

3 - AND et OR

10° Voici la fonction contientLesMots() qui vérifie qu'une page HTML donnée contient les mots demandées par l'auteur d'une recherche (sur Duck Duck Go par exemple) :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
def recherche(html, mot1, mot2, mot3): '''Renvoie True dans certains cas... :: param html(str) :: le code HTML d'une page :: param mot1(str) :: un mot qu'on recherche :: param mot2(str) :: un mot qu'on recherche :: param mot3(str) :: un mot qu'on recherche :: return (bool) :: True dans certains cas. Mais lequel ou lesquels ? ''' reponse = False if mot1 in html: if mot2 in html: if mot3 in html: reponse = True return reponse

QUESTION : cette structure est-elle similaire à

  1. un ET (on obtient True uniquement si toutes les expressions sont évaluées True)
  2. 1 2
    def recherche(html, mot1, mot2, mot3): return (mot1 in html) and (mot2 in html) and (mot3 in html)
  3. un OU (on obtient False uniquement si toutes les expressions sont évaluées False)
  4. 1 2
    def recherche(html, mot1, mot2, mot3): return (mot1 in html) or (mot2 in html) or (mot3 in html)

...CORRECTION...

Pour arriver en ligne 15 et effectuer l'affectation à True, il faut que les trois conditions soient True puisqu'elle sont imbriquées les unes dans les autres :

  • Pour atteindre la ligne 15, il faut que la condition de la ligne 14 soit True mais
  • pour atteindre la ligne 14, il faut que la condition de la ligne 13 soit True mais
  • pour atteindre la ligne 13, il faut que la condition de la ligne 12 soit True.
  • La fonction agit donc comme la fonction comportant des and.

1 2
def recherche(html, mot1, mot2, mot3): return (mot1 in html) and (mot2 in html) and (mot3 in html)

11° Voici la fonction contientLesMots() qui vérifie qu'une page HTML donnée contient les mots demandées par l'auteur d'une recherche (sur Duck Duck Go par exemple) :

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
def recherche(html, mot1, mot2, mot3): '''Renvoie True dans certains cas... :: param html(str) :: le code HTML d'une page :: param mot1(str) :: un mot qu'on recherche :: param mot2(str) :: un mot qu'on recherche :: param mot3(str) :: un mot qu'on recherche :: return (bool) :: True dans certains cas. Mais lequel ou lesquels ? ''' reponse = False if mot1 in html: reponse = True elif mot2 in html: reponse = True elif mot3 in html: reponse = True return reponse

QUESTION : cette structure est-elle similaire à

  1. un ET (on obtient True uniquement si toutes les expressions sont évaluées True)
  2. 1 2
    def recherche(html, mot1, mot2, mot3): return (mot1 in html) and (mot2 in html) and (mot3 in html)
  3. un OU (on obtient False uniquement si toutes les expressions sont évaluées False)
  4. 1 2
    def recherche(html, mot1, mot2, mot3): return (mot1 in html) or (mot2 in html) or (mot3 in html)

...CORRECTION...

Pour atteindre une affectation à True, on voit qu'il faut arriver soit en ligne 13, soit en ligne 15, soit en ligne 17. Cela correspond donc bien à un OU.

1 2
def recherche(html, mot1, mot2, mot3): return (mot1 in html) or (mot2 in html) or (mot3 in html)

12° Compléter l'unique ligne de la fonction contientSpecial() qui renvoit True si le mot de passe contient au moins l'un des caractères spéciaux suivant : ? ! $. Un seul suffit, deux ou trois ca passe aussi. Elle doit donc répondre False uniquement si elle ne contient aucun de ces caractères spéciaux.

Attention : remplacer pass par une ligne unique.

1 2 3
def contientSpecial(mdp): "Renvoie True si le mdp contient un des caractères spéciaux" pass

...CORRECTION...

1 2 3
def contientSpecial(mdp): "Renvoie True si le mdp contient un des caractères spéciaux" return ("?" in mdp) or ("!" in mdp) or ("$" in mdp)

Activité publiée le 15 11 2021
Dernière modification : 15 11 2021
Auteur : ows. h.