Prendre des décisions : les conditions `if`, `elif`, `else`

L'instruction `if` : exécuter du code sous condition

La brique de base de la prise de décision en Python est l'instruction `if`. Elle permet d'exécuter un bloc de code uniquement si une condition spécifiée est vraie (`True`). La syntaxe est simple : le mot-clé `if`, suivi d'une expression booléenne (la condition), puis de deux-points (`:`). Le bloc de code à exécuter si la condition est vraie doit être indenté (généralement avec 4 espaces) sous l'instruction `if`.

temperature = 25

if temperature > 20:
    print("Il fait chaud !")
    print("Pensez à vous hydrater.")

print("Fin du programme.") # Cette ligne s'exécute toujours, car non indentée sous le if

La condition peut être n'importe quelle expression qui s'évalue à `True` ou `False`. Cela inclut les comparaisons directes (comme `age >= 18`), les valeurs booléennes elles-mêmes (`if est_connecte:`), ou des expressions plus complexes combinant des opérateurs logiques (`and`, `or`, `not`). L'indentation est cruciale en Python ; c'est elle qui définit la portée du bloc `if`.

L'instruction `else` : une alternative quand la condition `if` est fausse

Souvent, vous voudrez exécuter un certain bloc de code si une condition est vraie, et un autre bloc de code si cette même condition est fausse. C'est là qu'intervient l'instruction `else`. Elle est toujours associée à une instruction `if` précédente et ne prend pas de condition propre. Le bloc de code sous `else` est exécuté uniquement si la condition du `if` (et de tous les `elif` éventuels) est fausse.

age = 16

if age >= 18:
    print("Vous êtes majeur.")
else:
    print("Vous êtes mineur.")
    print("L'accès est restreint.")

L'instruction `else` doit être au même niveau d'indentation que l'instruction `if` à laquelle elle se rapporte, et elle est également suivie de deux-points (`:`), avec son bloc de code indenté. Une structure `if-else` garantit qu'un des deux chemins sera pris.

L'instruction `elif` : gérer plusieurs conditions alternatives

Lorsque vous avez plus de deux issues possibles, c'est-à-dire que vous voulez tester plusieurs conditions en séquence, l'instruction `elif` (contraction de "else if") devient très utile. Elle vous permet de spécifier une nouvelle condition à tester si la condition du `if` précédent (et de tous les `elif` précédents) était fausse. Vous pouvez avoir autant de blocs `elif` que nécessaire.

note = 75

if note >= 90:
    grade = "A"
elif note >= 80:
    grade = "B"
elif note >= 70:
    grade = "C"
elif note >= 60:
    grade = "D"
else:
    grade = "E" # Echec

print(f"Votre grade est : {grade}")

L'ordre des `elif` est important, car il peut affecter la logique si les conditions se chevauchent. Par exemple, si nous avions mis `elif note >= 70:` avant `elif note >= 80:`, une note de 85 aurait abouti au grade "C" incorrectement. Un `else` final est optionnel mais souvent utile pour attraper tous les cas non couverts par les `if` et `elif`.

Conditions imbriquées et bonnes pratiques

Il est possible d'imbriquer des structures `if/elif/else` à l'intérieur d'autres structures `if/elif/else`. Cela permet de créer des logiques de décision plus complexes et granulaires. Cependant, une imbrication excessive peut rapidement rendre le code difficile à lire et à maintenir.

utilisateur_connecte = True
est_admin = False

if utilisateur_connecte:
    print("Utilisateur connecté.")
    if est_admin:
        print("Accès administrateur accordé.")
    else:
        print("Accès utilisateur standard.")
else:
    print("Veuillez vous connecter.")

• Soyez clair et concis : Formulez vos conditions de la manière la plus simple possible.
• Utilisez des noms de variables booléennes explicites : `if fichier_existe:` est plus clair que `if x == True:`.
• Commentez les logiques complexes : Si une condition est particulièrement alambiquée, un petit commentaire peut aider.
• Evitez les imbrications trop profondes : Si vous avez plus de 2 ou 3 niveaux d'imbrication, envisagez de réorganiser votre code, peut-être en utilisant des fonctions ou en simplifiant la logique. Parfois, l'utilisation d'opérateurs logiques `and` ou `or` peut aplatir des `if` imbriqués.

Les structures conditionnelles sont l'épine dorsale de la logique de programmation. Une bonne maîtrise de `if`, `elif`, et `else` est essentielle pour écrire des programmes Python qui se comportent comme prévu et s'adaptent à diverses situations.