Accueil › Les structures conditionnelles

Les structures conditionnelles

Mémo

La structure if / elif / else
if condition1:
    bloc1          # exécuté si condition1 est vraie
elif condition2:
    bloc2          # exécuté si condition1 est fausse ET condition2 est vraie
else:
    bloc3          # exécuté si toutes les conditions sont fausses
  • Le elif et le else sont facultatifs ;
  • On peut enchaîner autant de elif que nécessaire ;
  • L'indentation (quatre espaces) délimite les blocs.
Opérateurs de comparaison
==
Égalité (ne pas confondre avec = qui est l'affectation).
!=
Différent de.
<, <=, >, >=
Comparaisons d'ordre.
in
Appartenance : "a" in "chat" renvoie True.
Opérateurs logiques
and
Conjonction : True si les deux opérandes sont vrais.
or
Disjonction : True si au moins un opérande est vrai.
not
Négation : inverse la valeur de vérité.

Priorité : not $>$ and $>$ or. En cas de doute, utiliser des parenthèses.

Pièges fréquents
  • Écrire if x = 5 au lieu de if x == 5 (affectation au lieu de comparaison) ;
  • Écrire if x == True au lieu de simplement if x ;
  • Oublier les deux-points après la condition ;
  • Tester un intervalle avec if 0 < x and x < 10 alors que Python autorise l'écriture chaînée : if 0 < x < 10.

Exemples

Classification d'un nombre
def signe(n):
    if n > 0:
        return "positif"
    elif n < 0:
        return "négatif"
    else:
        return "nul"
Année bissextile
def est_bissextile(annee):
    # Divisible par 4 MAIS pas par 100, SAUF si divisible par 400
    return (annee % 4 == 0 and annee % 100 != 0) or (annee % 400 == 0)
Mention au baccalauréat
def mention(moyenne):
    if moyenne >= 16:
        return "Très bien"
    elif moyenne >= 14:
        return "Bien"
    elif moyenne >= 12:
        return "Assez bien"
    elif moyenne >= 10:
        return "Admis"
    else:
        return "Non admis"
Évaluation paresseuse (short-circuit)
# Python n'évalue pas la seconde condition si la première suffit
def divise(a, b):
    if b != 0 and a % b == 0:   # pas d'erreur si b == 0
        return True
    return False
Comparaisons chaînées
x = 7
print(0 < x < 10)     # True (équivaut à 0 < x and x < 10)
print(1 <= x <= 5)     # False

Exercices

Exercice 1 — Catégorie d'âge
2 pts

Écrire une fonction categorie(age) qui renvoie :

  • "enfant" si l'âge est strictement inférieur à 12 ;
  • "adolescent" entre 12 et 17 inclus ;
  • "adulte" à partir de 18.
▶ Voir la solution 
def categorie(age):
    if age < 12:
        return "enfant"
    elif age <= 17:
        return "adolescent"
    else:
        return "adulte"

Remarque : pas besoin de tester age >= 12 dans le elif car si on y arrive, c'est que la première condition est fausse (donc age >= 12).

Exercice 2 — Triangle valide
3 pts

Écrire une fonction type_triangle(a, b, c) qui prend trois longueurs et renvoie :

  • "invalide" si l'inégalité triangulaire n'est pas vérifiée ;
  • "équilatéral" si les trois côtés sont égaux ;
  • "isocèle" si exactement deux côtés sont égaux ;
  • "quelconque" sinon.
▶ Voir la solution 
def type_triangle(a, b, c):
    if a + b <= c or a + c <= b or b + c <= a:
        return "invalide"
    elif a == b == c:
        return "équilatéral"
    elif a == b or b == c or a == c:
        return "isocèle"
    else:
        return "quelconque"

Principe : on teste d'abord le cas invalide (inégalité triangulaire stricte). Ensuite, l'ordre est important : un triangle équilatéral est aussi isocèle, il faut donc tester l'équilatéral en premier.

Vérification :

  • type_triangle(3, 3, 3) renvoie "équilatéral" ;
  • type_triangle(3, 3, 5) renvoie "isocèle" ;
  • type_triangle(1, 1, 3) renvoie "invalide" car $1 + 1 ⩽ 3$.
Exercice 3 — Opérateurs logiques
3 pts

Sans exécuter le code, déterminer la valeur affichée pour chaque ligne :

a, b, c = 5, 0, -3
print(a > 0 and b > 0)           # Ligne 1
print(a > 0 or b > 0)            # Ligne 2
print(not (a > 0))               # Ligne 3
print(a > 0 and not b == 0)      # Ligne 4
print(c < 0 or a + c > 10)       # Ligne 5
print(not (a > 0 and c > 0))     # Ligne 6
▶ Voir la solution
  1. False : a > 0 est True mais b > 0 est False, et True and False = False.
  2. True : a > 0 est True, et True or False = True.
  3. False : a > 0 est True, donc not True = False.
  4. False : not b == 0 vaut not True = False, et True and False = False.
  5. True : c < 0 est True, Python n'évalue même pas la suite (évaluation paresseuse).
  6. True : a > 0 and c > 0 vaut True and False = False, donc not False = True. C'est la loi de De Morgan : $\overline{A \cap B} = \overline{A} \cup \overline{B}$.
Exercice 4 — Tarif de bus
2 pts

Le tarif d'un trajet en bus dépend de l'âge et du statut :

  • Gratuit pour les moins de 4 ans ;
  • Tarif réduit (0{,}80 €) pour les 4--17 ans ou les étudiants ;
  • Plein tarif (1{,}60 €) sinon.

Écrire une fonction tarif_bus(age, etudiant) où etudiant est un booléen.

▶ Voir la solution 
def tarif_bus(age, etudiant):
    if age < 4:
        return 0
    elif age <= 17 or etudiant:
        return 0.80
    else:
        return 1.60

Vérification :

  • tarif_bus(3, False) renvoie 0 ;
  • tarif_bus(15, False) renvoie 0.80 ;
  • tarif_bus(22, True) renvoie 0.80 ;
  • tarif_bus(30, False) renvoie 1.60.
← Retour aux fiches
© eduLaTeX 2026