Séance 3 : Structures conditionnelles, choix multiples (Selon / match-case) & TDO

Phase {{ currentPhase === 'all' ? 'Toutes' : currentPhase + ' / ' + phases.length }}

Phase active :

{{ currentPhase === 'all' ? 'Vue complète (Toutes les phases affichées)' : phases[currentPhase - 1].title }}

Étape 1

Accroche et situation-problème

10 minutes

Énoncé au tableau

« Un centre sportif calcule le tarif d'un accès journalier (tarif de base : 20 DT). Le client fournit son âge et un code de formule sous forme d'un caractère : 'P' (Piscine : +5 DT), 'M' (Musculation : +10 DT) ou 'T' (Total : +15 DT). Tout autre code entraîne un message d'erreur. De plus, une remise est accordée selon l'âge : gratuit pour les moins de 12 ans, 50% de réduction pour les juniors (12 à 17 ans inclus) et 20% pour les seniors (60 ans et plus). Calculer et afficher le prix net à payer. »

Cette situation permet de mobiliser les deux types d'arbres décisionnels : le choix multiple sur valeurs discrètes (sélecteur caractère) et la décision en cascade sur intervalles numériques continus (tranches d'âge).

1. Formules & Suppléments (Choix multiple) :

'P' ou 'p' Piscine
+5 DT
'M' ou 'm' Musculation
+10 DT
'T' ou 't' Accès Total
+15 DT
Autre code Code non reconnu
Erreur

Tarif brut = Tarif de base (20 DT) + Supplément.

2. Remises par Tranche d'Âge (Conditions continues) :

< 12 ans Enfants
Gratuit (100% remise)
12 à 17 ans Juniors
-50% (prix × 0.5)
≥ 60 ans Seniors
-20% (prix × 0.8)
18 à 59 ans Adultes
Tarif plein (100%)

Évalué avec une structure conditionnelle généralisée (Si ... Sinon Si ... Sinon).

Questionnement oral (cliquez pour afficher la réponse didactique) :

En Algorithmique :

En Python 3 :

Étape 2

Tableau de correspondance : Algorithmique ↔ Python

15 minutes

Mise au point sur les équivalences normatives officielles pour les structures conditionnelles et les opérateurs (Conventions 2024-2025) :

Structure / Opération	Algorithmique (Norme)	Python (Conventions 2024-2025)
Forme simple	`Si Condition Alors Traitement FinSi`	`if Condition : Traitement`
Forme alternative	`Si Condition Alors Traitement1 Sinon Traitement2 FinSi`	`if Condition : Traitement1 else : Traitement2`
Forme généralisée	`Si C1 Alors ... Sinon Si C2 Alors ... Sinon ... FinSi`	`if C1 : ... elif C2 : ... else : ...`
Choix multiple	`Selon Sélecteur val1 : T1 val2, val3 : T2 [Sinon TN] Fin Selon`	`match Sélecteur : case val1 : T1 case val2 \| val3 : T2 case _ : TN`
Opérateurs logiques	`Non`, `Et`, `Ou`	`not`, `and`, `or`
Opérateurs de comparaison	`=`, `≠`, `<`, `≤`, `>`, `≥`, `∈`	`==`, `!=`, `<`, `≤`, `>`, `≥`, `in`

Rappels didactiques et normatifs majeurs :

Type scalaire obligatoire pour le Selon : Le sélecteur de la structure Selon doit être impérativement de type Entier ou Caractère.
Clause par défaut en Python : Dans le bloc match-case, le tiret de soulignement case _ : représente la clause par défaut équivalente au Sinon du Selon.
Indentation syntaxique obligatoire : En Python, l'indentation (4 espaces) remplace impérativement les délimiteurs textuels (FinSi, Fin Selon).

Test d'égalité : = vs ==

En algorithmique, l'égalité se note = (l'affectation étant ←). En Python, le test d'égalité s'écrit obligatoirement ==.

valide ← (age = 18)
valide = (age == 18)

Alternative match-case (|)

Pour grouper plusieurs valeurs dans un case en Python, on emploie le symbole pipe | et jamais la virgule.

# Valide en Python 3 :
case "P" | "p":
# INTERDIT : case "P", "p":

Encadrement numérique

En algorithmique, l'encadrement nécessite Et. En Python, la double comparaison chaînée est directement acceptée.

(age ≥ 12) Et (age ≤ 17)
12 <= age <= 17

Étape 3

Conception algorithmique & T.D.O. Standard

20 minutes

Construction guidée de la solution au tableau : articulation rigoureuse entre la structure à choix multiple et les conditions généralisées.

ALGORITHME TarifAcces Algorithme Principal

ALGORITHME TarifAcces
DEBUT
    Écrire("Donner l'âge du client : ")
    Lire(age)
    Écrire("Donner le code de formule (P, M ou T) : ")
    Lire(formule)
    
    supplement ← 0
    valide ← Vrai
    
    Selon formule
        "P", "p" : supplement ← 5
        "M", "m" : supplement ← 10
        "T", "t" : supplement ← 15
        Sinon
            valide ← Faux
    Fin Selon
    
    Si Non valide Alors
        Écrire("Formule invalide !")
    Sinon
        prix_brut ← 20 + supplement
        
        Si age < 12 Alors
            prix_net ← 0
        Sinon Si (age ≥ 12) Et (age ≤ 17) Alors
            prix_net ← prix_brut * 0.5
        Sinon Si age ≥ 60 Alors
            prix_net ← prix_brut * 0.8
        Sinon
            prix_net ← prix_brut
        FinSi
        
        Écrire("Montant net à payer : ", prix_net, " DT")
    FinSi
FIN

T.D.O. Standard Objets Globaux

Objet	Type / Nature
age, supplement	Entier
prix_brut, prix_net	Réel
formule	Caractère
valide	Booléen

Commentaires méthodologiques :

formule : Variable de type Caractère servant de sélecteur scalaire au Selon.
valide : Drapeau booléen (flag) pour stopper proprement l'évaluation en cas d'erreur de saisie.
prix_net : Déclaré comme Réel pour accueillir les valeurs après calcul des réductions en pourcentage.

Étape 4

Traduction, Exécution sur machine & Laboratoire

20 minutes

Saisie individuelle du script Python par les élèves en appliquant rigoureusement les conventions officielles (Python 3.10+) :

tarif_acces.py

# Entrées
age = int(input("Donner l'âge du client : "))
formule = input("Donner le code de formule (P, M ou T) : ")

# Structure à choix multiples (match / case)
supplement = 0
valide = True
match formule:
    case "P" | "p":
        supplement = 5
    case "M" | "m":
        supplement = 10
    case "T" | "t":
        supplement = 15
    case _:
        valide = False

# Traitement conditionnel imbriqué et généralisé
if not valide:
    print("Formule invalide !")
else:
    prix_brut = 20 + supplement
    if age < 12:
        prix_net = 0.0
    elif 12 <= age <= 17:
        prix_net = prix_brut * 0.5
    elif age >= 60:
        prix_net = prix_brut * 0.8
    else:
        prix_net = float(prix_brut)
    print("Montant net à payer :", prix_net, "DT")

Points d'attention & Vigilance enseignant

Respect de l'opérateur pipe | dans case :
Vérifier l'utilisation impérative de la barre verticale case "P" | "p": pour l'alternative. La virgule , est une faute de syntaxe dans ce contexte.

Différenciation stricte de l'affectation et de l'égalité :
Veiller à ce que l'opérateur de comparaison == ne soit jamais confondu avec l'affectation = dans les expressions booléennes.

Rigueur absolue des niveaux d'indentation :
Contrôler l'alignement des sous-blocs : le bloc intérieur au match, puis l'imbrication du if-elif-else à l'intérieur du else principal.

Simulateur Interactif : Arbre de Décision & Tarification en direct

Cas types :

Âge du client (Entier ≥ 0) :

age = ans

Code de formule (Caractère) :

Saisie libre :

Branche A : Structure match formule (Choix Multiple)

case "P" | "p": Active

supplement = 5 DT | Formule Piscine

case "M" | "m": Active

supplement = 10 DT | Formule Musculation

case "T" | "t": Active

supplement = 15 DT | Formule Totale

case _: (Sinon) Active (Erreur)

valide = False | Code de formule invalide !

Branche B : Structure if-elif-else sur l'âge (Conditions continues)

if age < 12: Active

prix_net = 0.0 DT | Enfant (< 12 ans) : Gratuit (100%)

elif 12 ≤ age ≤ 17: Active

prix_net = brut × 0.5 | Junior (12-17 ans) : Remise de 50%

elif age ≥ 60: Active

prix_net = brut × 0.8 | Senior (≥ 60 ans) : Remise de 20%

else: Active

prix_net = brut | Adulte (18-59 ans) : Plein tarif standard

Détail du calcul pas-à-pas :

Tarif de base journalier : 20.0 DT

Formule choisie : {{ formuleNom }}

Validité (valide) : {{ isFormuleValid ? 'Vrai / True' : 'Faux / False (Invalide)' }}

Prix brut calculé (20 + supp) : {{ isFormuleValid ? (prixBrut + '.0 DT') : 'Non calculé' }}

Remise appliquée sur l'âge : {{ isFormuleValid ? reductionLabel : 'Aucune' }}

Montant net final à payer : {{ isFormuleValid ? prixNetFormatted : 'Erreur formule' }}

Sortie console Python (Terminal)

Étape 5

Bilan, Synthèse d'ancrage et Auto-évaluation

5 minutes

Contrôle oral rapide (Questions Flash de clôture) :

Question didactique

Afficher la réponse

Algo : {{ f.resAlgo }}

Quiz d'auto-évaluation interactif

Testez vos acquis sur les structures conditionnelles, match-case, les opérateurs logiques et le TDO.

Score : {{ quizScore }} / {{ quizQuestions.length }}

Q{{ idx + 1 }}. {{ q.question }}

Explication didactique : {{ q.explanation }}