# Tests Imbriqués Les tests imbriqués sont un concept fondamental en algorithmique, permettant de gérer des prises de décision complexes et hiérarchisées. Ils sont essentiels pour structurer des logiques conditionnelles où la validité ou la pertinence d'une condition dépend de l'issue d'une condition précédente. > [!video] Vidéo explicative > <iframe width="560" height="315" src="https://www.youtube.com/embed/PXFo8_2cYXQ?si=iVs29wmdAntS5Vsp" title="YouTube video player" frameborder="0" allow="accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share" referrerpolicy="strict-origin-when-cross-origin" allowfullscreen></iframe> ## 1. Introduction aux Tests Imbriqués En programmation, les structures conditionnelles (`SI...ALORS...SINON`) permettent d'exécuter différents blocs d'instructions en fonction de la valeur de vérité d'une ou plusieurs conditions. Lorsque la décision à prendre nécessite d'évaluer une condition *après* qu'une première condition ait été jugée vraie (ou fausse), on parle de tests imbriqués. > [!definition] Test Imbriqué > Un test imbriqué est une structure conditionnelle (`SI...ALORS...SINON`) placée à l'intérieur d'une autre structure conditionnelle. La condition interne n'est évaluée que si la condition externe (qui la contient) est satisfaite. Ce concept s'appuie directement sur la logique combinatoire pour la construction des conditions et peut être représenté visuellement par des algorigrammes où des losanges de décision sont contenus dans les branches d'autres losanges. ## 2. Structure et Syntaxe La structure des tests imbriqués suit une hiérarchie claire. Une condition est évaluée, et si elle est vraie (ou fausse, selon la branche), une nouvelle condition est alors évaluée. ### 2.1. Pseudo-code de base ``` SI Condition_Externe ALORS { // Bloc d'instructions exécuté si Condition_Externe est VRAIE SI Condition_Interne ALORS { // Bloc d'instructions exécuté si Condition_Externe est VRAIE ET Condition_Interne est VRAIE } } ``` ### 2.2. Pseudo-code avec branches `SINON` L'imbrication peut se faire dans n'importe quelle branche (`ALORS` ou `SINON`) d'une structure conditionnelle. ``` SI Condition_A ALORS { SI Condition_B ALORS { // Actions si Condition_A est VRAIE ET Condition_B est VRAIE } SINON { // Actions si Condition_A est VRAIE ET Condition_B est FAUSSE } } SINON { SI Condition_C ALORS { // Actions si Condition_A est FAUSSE ET Condition_C est VRAIE } SINON { // Actions si Condition_A est FAUSSE ET Condition_C est FAUSSE } } ``` > [!note] Indentation > L'indentation est cruciale pour la lisibilité du pseudo-code et du code réel. Elle permet de visualiser clairement la hiérarchie des tests et les blocs d'instructions associés à chaque condition. C'est une pratique essentielle en programmation, notamment en Python. ## 3. Exemples Pratiques ### 3.1. Exemple simple : Vérifier un nombre positif et pair Imaginons que nous voulions vérifier si un nombre $N$ est à la fois positif et pair. > [!example] Vérification de nombre > ``` > LIRE N > SI N > 0 ALORS > { > // Le nombre est positif, on peut vérifier s'il est pair > SI N MOD 2 == 0 ALORS > { > AFFICHER "Le nombre est positif et pair." > } > SINON > { > AFFICHER "Le nombre est positif mais impair." > } > } > SINON > { > // Le nombre n'est pas positif > AFFICHER "Le nombre n'est pas positif." > } > ``` > Dans cet exemple, la vérification de parité `N MOD 2 == 0` n'a de sens dans le contexte "positif et pair" que si `N > 0` est déjà vrai. ### 3.2. Exemple plus complexe : Catégorisation d'utilisateur Classer un utilisateur selon son âge et son statut (étudiant ou non). > [!example] Catégorisation d'utilisateur > ``` > LIRE Age > LIRE EstEtudiant (VRAI/FAUX) > > SI Age >= 18 ALORS > { > // L'utilisateur est majeur > SI EstEtudiant ALORS > { > AFFICHER "Utilisateur majeur et étudiant." > } > SINON > { > AFFICHER "Utilisateur majeur et non-étudiant." > } > } > SINON > { > // L'utilisateur est mineur > SI EstEtudiant ALORS > { > AFFICHER "Utilisateur mineur et étudiant." > } > SINON > { > AFFICHER "Utilisateur mineur et non-étudiant." > } > } > ``` ## 4. Tests Imbriqués vs. Opérateurs Logiques Il est important de distinguer les tests imbriqués de l'utilisation d'opérateurs logiques (`ET`, `OU`, `NON`). ### 4.1. Opérateur `ET` (conjonction) L'opérateur `ET` ($ \land $) permet de combiner plusieurs conditions qui doivent *toutes* être vraies pour que le bloc d'instructions associé soit exécuté. ``` SI Condition_A ET Condition_B ALORS { // Actions si Condition_A est VRAIE ET Condition_B est VRAIE } ``` Ceci est équivalent à : ``` SI Condition_A ALORS { SI Condition_B ALORS { // Actions si Condition_A est VRAIE ET Condition_B est VRAIE } } ``` > [!note] Quand choisir ? > - Utilisez l'opérateur `ET` quand une *seule* action ou un *seul* bloc d'instructions doit être exécuté si *toutes* les conditions sont vraies, et qu'il n'y a pas d'action spécifique si seulement une partie des conditions est vraie. > - Utilisez les tests imbriqués lorsque des actions *différentes* doivent être exécutées en fonction de l'état de chaque condition intermédiaire, ou lorsque la validité/pertinence de la condition interne dépend de l'externe (comme dans l'exemple du nombre positif et pair). ### 4.2. Opérateur `OU` (disjonction) L'opérateur `OU` ($ \lor $) permet d'exécuter un bloc d'instructions si *au moins une* des conditions est vraie. ``` SI Condition_A OU Condition_B ALORS { // Actions si Condition_A est VRAIE OU Condition_B est VRAIE (ou les deux) } ``` Les tests imbriqués sont généralement moins adaptés pour exprimer une logique `OU` simple, car ils mènent souvent à des structures plus complexes et moins lisibles pour ce cas. ## 5. Bonnes Pratiques et Considérations > [!warning] Complexité et Lisibilité > Un nombre excessif de niveaux d'imbrication peut rendre le code très difficile à lire, à comprendre et à maintenir. > [!tip] Refactorisation > Si vous vous retrouvez avec de nombreux niveaux d'imbrication, considérez les alternatives : > - **Opérateurs logiques** (`ET`, `OU`) pour aplatir les conditions si possible. > - **Fonctions ou procédures** pour encapsuler des logiques de décision complexes. > - **Tables de décision** pour des cas très complexes avec de nombreuses combinaisons de conditions. Les tests imbriqués sont un outil puissant, mais comme tout outil, ils doivent être utilisés judicieusement pour maintenir la clarté et l'efficacité de l'algorithme. ## 6. Résumé Les tests imbriqués sont un mécanisme essentiel en algorithmique pour gérer des prises de décision séquentielles et hiérarchisées. - Ils permettent d'évaluer une condition interne uniquement si une condition externe est satisfaite. - L'indentation est fondamentale pour la lisibilité et la compréhension de la structure. - Ils sont distincts des opérateurs logiques (`ET`, `OU`), bien qu'ils puissent parfois exprimer une logique similaire. Le choix dépend de la granularité des actions à effectuer à chaque étape de la décision. - Une utilisation excessive doit être évitée pour ne pas nuire à la lisibilité et à la maintenabilité de l'algorithme. La maîtrise des tests imbriqués est une étape cruciale avant d'aborder l'implémentation de ces structures dans des langages de programmation comme Python, où les mots-clés `if`, `elif`, et `else` sont utilisés. ## 🗓️ Historique > **Dernière mise à jour :** `26 octobre 2025` > **Rédigé par :** [[Julien DUQUENNOY]]