Conditions et booléens : MPSI Informatique

Vue d'ensemble

Un programme intéressant doit pouvoir choisir : faire une chose si une condition est vraie, une autre sinon. C'est le rôle du if, qui s'appuie sur les booléens (True / False) produits par les comparaisons. Sans conditions, un programme déroulerait toujours exactement la même suite d'instructions, quelles que soient les données : impossible de valider une saisie, de trier des cas, ou de réagir à un résultat. Maîtriser conditions et booléens, c'est la clé pour écrire des algorithmes qui réagissent, et c'est le socle des boucles et des fonctions que tu croiseras ensuite.

Objectif passerelle Terminale → Sup — Écrire et lire une structure conditionnelle sans erreur d'indentation, combiner des conditions avec and, or, not, et comprendre pourquoi un seul bloc s'exécute et dans quel ordre les tests sont évalués.

Prérequis

Variables, types et expressions (fiche précédente)
Différence entre = (affectation) et == (test)
L'opérateur modulo % (reste d'une division), utile pour tester la parité

🎯 Accompagnement Majorant

Les conditions imbriquées te perdent ? C'est un point qui bloque beaucoup à l'entrée en prépa. Nos mentors alumni X · Centrale · Mines t'apprennent à structurer ton raisonnement pour ne plus jamais te tromper de branche.

Trouver un mentor →

1. Booléens et comparaisons

Définition 1.1 — Booléen

Un booléen est une valeur de vérité : True (vrai) ou False (faux). C'est le plus petit type de Python, mais celui qui pilote toutes les décisions. Une comparaison est une expression qui produit un booléen.

Il existe six opérateurs de comparaison. Chacun renvoie True ou False, jamais autre chose :

3 == 3      # True   : egalite (double egal)
3 != 5      # True   : different
2 < 5       # True   : strictement inferieur
5 <= 5      # True   : inferieur ou egal
7 > 10      # False  : strictement superieur ? non
6 >= 6      # True   : superieur ou egal
3 == 3.0    # True   : meme valeur, meme si int et float

🔍 Décryptage ligne par ligne

== et !=Égal / différent. == (double égal) teste une égalité et renvoie un booléen ; = (simple) affecte une valeur à une variable. Les confondre dans un if est l'erreur n°1 des débutants.

< <= > >=Comparaisons d'ordre. Le = se place toujours à droite (<=, pas =<). Chacune renvoie True ou False.

3 == 3.0int vs float. La comparaison porte sur la valeur mathématique, pas sur le type : 3 == 3.0 vaut True même si l'un est un entier et l'autre un flottant.

💡 Comparer des chaînes. Les opérateurs marchent aussi sur les chaînes de caractères, selon l'ordre alphabétique (plus précisément l'ordre des codes Unicode) :

"abricot" < "banane"   # True  : 'a' vient avant 'b'
"chat" == "chat"       # True  : memes caracteres
"Chat" == "chat"       # False : majuscule et minuscule different
"chat" < "chien"       # True  : 'a' vient avant 'i' au 3e caractere

Deux mots sont comparés lettre par lettre, de gauche à droite, jusqu'à la première différence.

📝 Un booléen est une valeur comme une autre. On peut le stocker dans une variable : majeur = age >= 18 range directement True ou False dans majeur. Pas besoin d'écrire if pour obtenir un booléen.

2. La structure if / elif / else

On exécute un bloc seulement si une condition est vraie. L'indentation (décalage à droite, quatre espaces par convention) délimite le bloc : en Python, elle n'est pas décorative, elle fait partie de la syntaxe. Le : en fin de ligne annonce le bloc qui suit.

note = 12

if note >= 16:
    mention = "tres bien"
elif note >= 12:
    mention = "assez bien"
else:
    mention = "sans mention"

print(mention)   # affiche : assez bien

🔍 Décryptage ligne par ligne

if note >= 16:Première condition. Si elle est vraie, on exécute le bloc indenté et on saute tout le reste (elif/else). Ici 12 >= 16 est faux, on passe à la suite.

mention = "..."Le bloc indenté. Ces lignes décalées de quatre espaces appartiennent au if. Elles ne s'exécutent que si la condition juste au-dessus est vraie.

elif note >= 12:« sinon si ». Testé seulement si toutes les conditions précédentes sont fausses. 12 >= 12 est vrai → mention = "assez bien", et on saute le else.

else:Cas par défaut. Pas de condition : exécuté seulement si toutes les conditions au-dessus sont fausses.

Méthode — Lire un if / elif / else

Repère la valeur de départ des variables testées.
Descends les conditions de haut en bas et arrête-toi à la première vraie.
Exécute uniquement son bloc indenté, puis saute tout le reste de la structure.
Si aucune condition n'est vraie et qu'il y a un else, exécute son bloc ; sinon, rien ne se passe.

📝 Un seul bloc s'exécute. Dans un if / elif / else, exactement un bloc au maximum est exécuté : le premier dont la condition est vraie. Ce n'est pas comme écrire plusieurs if indépendants, où chacun serait testé séparément.

⚠ L'ordre des tests compte. Comme un seul bloc s'exécute (le premier vrai), il faut tester du plus exigeant au moins exigeant. Si on mettait note >= 12 avant note >= 16, une note de 18 tomberait dans « assez bien » : le premier test 18 >= 12 serait vrai et on ne regarderait jamais le suivant.

3. Combiner des conditions : and, or, not

Souvent une décision dépend de plusieurs critères. Les trois opérateurs logiques and, or et not permettent d'assembler des booléens en une seule condition.

age = 20
etudiant = True

age >= 18 and etudiant    # True  : les DEUX doivent etre vraies
age < 12 or etudiant      # True  : au moins UNE vraie suffit
not etudiant              # False : inverse le booleen

🔍 Décryptage

andET. Vrai seulement si les deux conditions sont vraies. Dès qu'une est fausse, le résultat est faux.

orOU. Vrai si au moins une des deux est vraie. Faux seulement si les deux sont fausses.

notNON. Inverse la valeur : not True vaut False, not False vaut True.

Tables de vérité de `and`, `or` et `not`
A	B	A and B	A or B	not A
True	True	True	True	False
True	False	False	True	False
False	True	False	True	True
False	False	False	False	True

Retiens les deux lignes clés : and n'est vrai que sur la première ligne (tout vrai), or n'est faux que sur la dernière (tout faux).

📝 Encadrer une valeur. Pour tester « x entre 0 et 10 inclus », on écrit 0 <= x and x <= 10. Python autorise même l'écriture mathématique directe 0 <= x <= 10, qui a exactement le même sens et se lit comme un encadrement.

💡 Combiner dans un if. On peut mettre une condition composée directement après if :

temperature = 8
pluie = True

if temperature < 10 and pluie:
    print("prends un manteau et un parapluie")
else:
    print("ca ira")

Ici 8 < 10 est vrai et pluie est vrai, donc le and est vrai : le programme affiche le premier message.

4. Conditions imbriquées et court-circuit

Un if peut contenir un autre if dans son bloc : on parle de conditions imbriquées. Cela sert quand un second choix n'a de sens que si le premier est déjà tranché. Il faut souvent choisir entre imbriquer et utiliser elif.

connecte = True
admin = False

if connecte:
    if admin:
        print("acces total")
    else:
        print("acces limite")
else:
    print("merci de vous connecter")

🔍 Décryptage ligne par ligne

if connecte:Choix externe. Vrai ici, on entre dans son bloc. Tout ce qui est indenté à l'intérieur ne sera examiné que pour un utilisateur connecté.

if admin:Choix interne. Indenté deux fois (huit espaces) : il n'existe que dans le cas « connecté ». admin vaut False, on saute au else interne.

else:Sinon interne. Rattaché au if admin par son niveau d'indentation → affiche « acces limite ».

else:Sinon externe. Aligné avec if connecte : ne concerne que les utilisateurs non connectés.

📝 Imbriquer ou utiliser elif ? Des elif enchaînés testent une suite de cas mutuellement exclusifs sur une même donnée (les mentions selon la note). L'imbrication convient quand chaque niveau pose une nouvelle question qui dépend du précédent (d'abord connecté, puis admin). Choisir la bonne forme rend le code beaucoup plus lisible.

Définition 4.1 — Évaluation paresseuse (court-circuit)

Python évalue les conditions de gauche à droite et s'arrête dès que le résultat est connu. Pour A and B, si A est faux, le résultat est déjà faux : B n'est même pas évalué. Pour A or B, si A est vrai, le résultat est déjà vrai et B est ignoré.

x = 0

if x != 0 and 10 / x > 1:
    print("grand")
else:
    print("evite la division")

🔍 Décryptage

x != 0Premier test. x vaut 0, donc x != 0 est False.

and 10 / x > 1Court-circuit. Comme le premier membre du and est faux, Python n'évalue jamais 10 / x. On évite ainsi une division par zéro qui aurait planté le programme.

elseRésultat. La condition globale est fausse → affichage « evite la division ».

📝 Valeurs vraies et fausses (léger, hors-programme). Placés seuls dans un if, certains objets valent implicitement False : le nombre 0, la chaîne vide "", la liste vide []. Presque tout le reste vaut True. Ainsi if maliste: se lit « si la liste n'est pas vide ». À connaître pour lire du code, mais au début écris plutôt la comparaison complète (if len(maliste) > 0:) pour rester explicite.

🎯 Passer un cap en algo

Le court-circuit et les branches imbriquées te semblent abstraits ? En stage intensif Majorant, tu traces chaque exécution à la main avec un mentor alumni X · Centrale · Mines jusqu'à ce que le raisonnement devienne un réflexe.

Voir les stages →

5. Exercices d'application

À faire de tête, en traçant l'exécution, avant d'ouvrir le corrigé.

Exo 1Prévoir l'affichageFacile

Que produit ce programme ?

x = 7
if x % 2 == 0:
    print("pair")
elif x > 5:
    print("impair et grand")
else:
    print("impair et petit")

Voir la correction détaillée

x % 2 = 7 % 2 = 1, donc 1 == 0 est faux : on saute le premier bloc.

On teste le elif : 7 > 5 est vrai → on exécute son bloc et on saute le else.

Affichage : impair et grand.

Exo 2Écrire une conditionIntermédiaire

Écris la condition d'un if vraie quand un entier n est un multiple de 3 et compris strictement entre 0 et 100.

Voir la correction détaillée

Multiple de 3 : le reste par 3 est nul, donc n % 3 == 0.

Strictement entre 0 et 100 : 0 < n and n < 100 (ou l'écriture directe 0 < n < 100).

On combine le tout avec and :

if n % 3 == 0 and 0 < n < 100:
    print("ok")

Exo 3Simplifier avec notIntermédiaire

Réécris cette condition sans not, de façon plus lisible :

if not (age >= 18):
    print("mineur")

Voir la correction détaillée

not (age >= 18) est vrai exactement quand age >= 18 est faux.

L'inverse de « supérieur ou égal à 18 » est « strictement inférieur à 18 », donc age < 18.

Version simplifiée :

if age < 18:
    print("mineur")

6. Erreurs classiques (les pièges qui coûtent des points)

Ces erreurs reviennent dans presque toutes les copies de début d'année. Les connaître, c'est déjà la moitié du travail pour les éviter.

⚠ Écrire = au lieu de ==. Dans un test, il faut le double égal. if note = 16: provoque une SyntaxError : = est une affectation, pas une comparaison. On écrit if note == 16:.

⚠ Oublier le : après if, elif ou else. Le deux-points annonce le bloc. Sans lui, if x > 0 déclenche une SyntaxError. Chaque if, elif, else se termine par :.

⚠ Se tromper d'indentation. Une ligne oubliée dans le bloc, ou un mélange d'espaces et de tabulations, casse la logique (ou lève une IndentationError). Reste régulier : quatre espaces par niveau, toujours.

⚠ Tester dans le mauvais ordre. Placer note >= 12 avant note >= 16 : comme le premier test vrai gagne, un 18 serait classé « assez bien ». Va du cas le plus restrictif au plus large.

⚠ Comparer un str et un int. input() renvoie toujours une chaîne. if reponse == 5: compare "5" (texte) à 5 (nombre) et vaut toujours False ; pire, "5" < 5 lève une TypeError. Convertis d'abord : reponse = int(input()).

6. Pour aller plus loin

Les conditions ne servent pleinement qu'associées aux autres briques du langage. Voici trois chapitres qui réinvestissent directement tout ce que tu viens de voir :

Les boucles while — une boucle répète un bloc tant qu'une condition est vraie : le booléen y devient le moteur de la répétition.
Les fonctions — une fonction peut faire un return d'un booléen (ex. est_pair(n) qui renvoie True ou False), condition prête à réutiliser partout.
Lire et tester un programme — s'entraîner à tracer l'exécution ligne par ligne, exactement la compétence mobilisée pour prévoir quelle branche d'un if s'exécute.

Récap final — Ce qu'il faut absolument retenir

Tu dois pouvoir répondre « oui » sans hésiter à chaque point.

Sais-tu qu'une comparaison (==, !=, <, <=, >, >=) produit toujours un booléen ?
Ne confonds-tu jamais = (affecte) et == (teste) ?
Sais-tu que 3 == 3.0 vaut True (comparaison sur la valeur) ?
Sais-tu que les chaînes se comparent dans l'ordre alphabétique, lettre par lettre ?
Sais-tu qu'un seul bloc du if / elif / else s'exécute (le premier vrai) ?
Sais-tu pourquoi l'ordre des tests compte (du plus exigeant au plus large) ?
Sais-tu que l'indentation délimite le bloc et que le : est obligatoire ?
Sais-tu combiner des conditions avec and, or, not et lire leur table de vérité ?
Sais-tu encadrer une valeur avec 0 <= x <= 10 ?
Sais-tu distinguer un if imbriqué d'une suite de elif ?
Sais-tu ce qu'est le court-circuit (A and B n'évalue pas B si A est faux) ?
Sais-tu qu'il faut convertir la saisie input() avant de la comparer à un nombre ?

Débloque la fiche complète

Théorèmes, démonstrations à savoir refaire, méthodes-types et pièges de concours : crée ton compte gratuit pour tout lire. Une seule fois pour toutes les fiches et ressources Majorant.

Nom

Prénom

Téléphone

Gratuit · vos données restent confidentielles.

Conditions et booléens

Vue d'ensemble

Prérequis

1. Booléens et comparaisons

2. La structure if / elif / else

3. Combiner des conditions : and, or, not

4. Conditions imbriquées et court-circuit

5. Exercices d'application

6. Erreurs classiques (les pièges qui coûtent des points)

6. Pour aller plus loin

Récap final — Ce qu'il faut absolument retenir

Débloque la fiche complète

Quiz — Conditions

Fiches associées

Recherche par dichotomie

Variables, types et affectations

Boucles for et while

Fonctions : paramètres et valeurs de retour

Listes et chaînes de caractères

Manipuler les listes

Tu veux aller plus loin sur ce chapitre ?