8. Prendre des décisions avec les instructions if

Dans les programmes que nous avons écrits jusqu’à présent, Python exécute chaque ligne de code de haut en bas, une instruction après l’autre. Mais les programmes du monde réel doivent prendre des décisions — exécuter du code différent selon des conditions différentes. Devons-nous afficher un message d’erreur ? Devons-nous calculer une remise ? Devons-nous redemander une saisie ? La réponse dépend de la situation.

Les instructions conditionnelles (conditional statements) permettent à vos programmes de prendre ces décisions. Elles permettent à Python d’exécuter certains blocs de code uniquement lorsque des conditions spécifiques sont vraies, et de les ignorer sinon. Ce chapitre présente l’instruction if de Python et ses variantes, qui constituent la base de la prise de décision dans vos programmes.

En maîtrisant les instructions conditionnelles, vous pourrez écrire des programmes qui réagissent intelligemment aux entrées utilisateur, gèrent correctement différents scénarios et résolvent des problèmes qui nécessitent un raisonnement logique.

8.1) Instructions if simples

La forme la plus basique de prise de décision en Python est l’instruction if simple. Elle dit à Python : « Si cette condition est vraie, exécutez ce bloc de code. Sinon, ignorez-le et continuez. »

8.1.1) La structure d’une instruction if

Voici la syntaxe de base d’une instruction if :

if condition:
    # Code à exécuter si condition est True
    statement1
    statement2
    # ... autres instructions

Décomposons chaque partie :

1. Le mot-clé if : il démarre l’instruction conditionnelle
2. La condition : une expression booléenne qui s’évalue à True ou False (du chapitre 7)
3. Les deux-points (:) : ils sont obligatoires et marquent la fin de la ligne de condition
4. Le bloc de code indenté : toutes les instructions indentées sous le if ne sont exécutées que lorsque la condition est True

L’indentation est cruciale en Python. Les lignes indentées forment un bloc de code (code block) qui appartient à l’instruction if. Python utilise l’indentation (généralement 4 espaces) pour déterminer quelles instructions font partie du bloc conditionnel.

Voici un exemple simple :

# temperature_check.py
temperature = 30
 
if temperature > 25:
    print("It's a warm day!")
    print("Consider wearing light clothing.")
 
print("Have a great day!")  # Cela s’exécute toujours

Output:

It's a warm day!
Consider wearing light clothing.
Have a great day!

Dans cet exemple :

• La condition temperature > 25 s’évalue à True (puisque 30 > 25)
• Les deux instructions print() indentées s’exécutent parce qu’elles font partie du bloc if
• La dernière instruction print() s’exécute toujours parce qu’elle n’est pas indentée — elle ne fait pas partie du bloc if

Voyons maintenant ce qui se passe lorsque la condition est False :

# temperature_check_cool.py
temperature = 18
 
if temperature > 25:
    print("It's a warm day!")
    print("Consider wearing light clothing.")
 
print("Have a great day!")  # Cela s’exécute toujours

Output:

Have a great day!

Cette fois :

• La condition temperature > 25 s’évalue à False (puisque 18 n’est pas supérieur à 25)
• Les deux instructions indentées sont entièrement ignorées
• Seul le dernier print() s’exécute parce qu’il est en dehors du bloc if

8.1.2) Utiliser des conditions du chapitre 7

Toute expression booléenne du chapitre 7 peut être utilisée comme condition dans une instruction if. Cela inclut :

Opérateurs de comparaison :

# voting_eligibility.py
age = 16
 
if age >= 18:
    print("You are eligible to vote.")
# Rien ne s’affiche parce que 16 >= 18 est False
 
score = 85
 
if score >= 60:
    print("You passed the exam!")  # Output: You passed the exam!

Tests d’appartenance avec in et not in :

# user_access.py
username = "alice"
banned_users = ["bob", "charlie", "dave"]
 
if username not in banned_users:
    print(f"Welcome, {username}!")  # Output: Welcome, alice!
 
favorite_color = "blue"
 
if "u" in favorite_color:
    print("Your favorite color contains the letter 'u'.")  # Output: Your favorite color contains the letter 'u'.

Valeurs booléennes directes :

# weather_check.py
is_raining = True
 
if is_raining:
    print("Don't forget your umbrella!")  # Output: Don't forget your umbrella!

Véracité et fausseté (truthiness and falsiness) (du chapitre 7.4) :

# name_input.py
user_input = input("Enter your name: ")
 
if user_input:  # La chaîne vide est falsy, une chaîne non vide est truthy
    print(f"Hello, {user_input}!")
else:
    print("You didn't enter a name.")

8.1.3) Plusieurs instructions dans le bloc if

Vous pouvez inclure autant d’instructions que nécessaire dans un bloc if. Toutes les instructions indentées sous la ligne if appartiennent à ce bloc :

# bank_withdrawal.py
balance = 1500
withdrawal = 200
 
if withdrawal <= balance:
    balance = balance - withdrawal  # Soustraire withdrawal de balance
    print(f"Withdrawal successful!")
    print(f"Your new balance is: ${balance}")
    print("Thank you for your transaction.")
 
print("Transaction complete.")  # S’exécute toujours

Output:

Withdrawal successful!
Your new balance is: $1300
Thank you for your transaction.
Transaction complete.

Les quatre instructions s’exécutent parce que withdrawal <= balance est True. Si nous modifions le retrait à 2000 :

# bank_withdrawal_insufficient.py
balance = 1500
withdrawal = 2000
 
if withdrawal <= balance:
    balance = balance - withdrawal
    print(f"Withdrawal successful!")
    print(f"Your new balance is: ${balance}")
    print("Thank you for your transaction.")
 
print("Transaction complete.")  # S’exécute toujours

Output:

Transaction complete.

Maintenant, aucune des instructions indentées ne s’exécute parce que la condition est False. Le solde reste inchangé à 1500.

8.2) Utiliser if-else pour des choix soit l’un, soit l’autre

Souvent, vous devez choisir entre deux alternatives : exécuter un bloc de code si une condition est vraie, et un autre bloc si elle est fausse. L’instruction if-else gère cette prise de décision binaire.

8.2.1) La structure de if-else

Voici la syntaxe :

if condition:
    # Code à exécuter si condition est True
    statement1
    statement2
else:
    # Code à exécuter si condition est False
    statement3
    statement4

La clause else fournit un chemin alternatif. Exactement un des deux blocs s’exécutera — jamais les deux, jamais aucun.

Voyons un exemple pratique :

# age_verification.py
age = int(input("Enter your age: "))
 
if age >= 18:
    print("You are an adult.")
    print("You can vote in elections.")
else:
    print("You are a minor.")
    print("You cannot vote yet.")
 
print("Thank you for providing your age.")

Si vous saisissez 25 :

You are an adult.
You can vote in elections.
Thank you for providing your age.

Si vous saisissez 15 :

You are a minor.
You cannot vote yet.
Thank you for providing your age.

Remarquez qu’exactement un des deux blocs s’exécute, selon la condition. La dernière instruction print() s’exécute toujours parce qu’elle est en dehors des deux blocs.

8.2.2) Prendre des décisions binaires

if-else est parfait pour des décisions binaires où il y a exactement deux résultats possibles :

# even_odd_checker.py
number = int(input("Enter a number: "))
 
if number % 2 == 0:
    print(f"{number} is even.")
else:
    print(f"{number} is odd.")

# password_verification.py
stored_password = "python123"
entered_password = input("Enter password: ")
 
if entered_password == stored_password:
    print("Access granted.")
    print("Welcome to the system!")
else:
    print("Access denied.")
    print("Incorrect password.")

8.3) Plusieurs choix avec if-elif-else

Les décisions du monde réel impliquent souvent plus de deux options. Devons-nous facturer une livraison standard, express ou en 24 heures ? Une note est-elle un A, B, C, D ou F ? La chaîne if-elif-else gère plusieurs alternatives mutuellement exclusives.

8.3.1) La structure de if-elif-else

Voici la syntaxe :

if condition1:
    # Exécuter si condition1 est True
    block1
elif condition2:
    # Exécuter si condition1 est False et condition2 est True
    block2
elif condition3:
    # Exécuter si condition1 et condition2 sont False, et condition3 est True
    block3
else:
    # Exécuter si toutes les conditions sont False
    block4

Points clés à propos des chaînes if-elif-else :

1. elif est l’abréviation de « else if » : il fournit des conditions supplémentaires à vérifier
2. L’ordre compte : Python vérifie les conditions de haut en bas
3. Le premier match gagne : dès qu’une condition est True, ce bloc s’exécute et le reste est ignoré
4. Exactement un bloc s’exécute : au plus un bloc dans la chaîne s’exécute
5. else est optionnel : il capture tous les cas non gérés par les conditions précédentes

Voyons un exemple pratique :

# grade_calculator.py
score = int(input("Enter your exam score (0-100): "))
 
if score >= 90:
    grade = "A"
    print("Excellent work!")
elif score >= 80:
    grade = "B"
    print("Good job!")
elif score >= 70:
    grade = "C"
    print("Satisfactory.")
elif score >= 60:
    grade = "D"
    print("You passed, but consider reviewing the material.")
else:
    grade = "F"
    print("Unfortunately, you did not pass.")
 
print(f"Your grade is: {grade}")

Si vous saisissez 85 :

Good job!
Your grade is: B

Traçons ce qui se passe :

1. Vérifier score >= 90 : False (85 n’est pas >= 90), donc ignorer ce bloc
2. Vérifier score >= 80 : True (85 >= 80), donc exécuter ce bloc
3. Ignorer tous les blocs elif et else restants parce que nous avons trouvé un match

Si vous saisissez 55 :

Unfortunately, you did not pass.
Your grade is: F

Toutes les conditions sont False, donc le bloc else s’exécute.

8.3.2) Pourquoi l’ordre compte dans les chaînes elif

L’ordre des conditions est crucial parce que Python arrête de vérifier dès qu’il trouve une condition True. Considérez ce système de notation incorrect :

# ORDRE INCORRECT - Ne faites pas ça !
score = 85
 
if score >= 60:  # Cela correspondra en premier !
    grade = "D"
elif score >= 70:
    grade = "C"
elif score >= 80:
    grade = "B"
elif score >= 90:
    grade = "A"
else:
    grade = "F"
 
print(f"Your grade is: {grade}")  # Output: Your grade is: D

Cela donne un mauvais résultat ! Le score de 85 devrait être un B, mais il obtient un D parce que score >= 60 est vérifié en premier et est True. Python n’atteint jamais la condition score >= 80.

Ordonnez toujours les conditions de la plus spécifique à la moins spécifique :

# ORDRE CORRECT
score = 85
 
if score >= 90:  # La plus spécifique
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
elif score >= 60:
    grade = "D"
else:  # La moins spécifique
    grade = "F"
 
print(f"Your grade is: {grade}")  # Output: Your grade is: B

8.3.3) Utiliser elif sans else

La clause else est optionnelle. Parfois, vous voulez uniquement gérer des cas spécifiques et ne rien faire pour les autres :

# weekend_checker.py
day = input("Enter a day of the week: ").lower()
 
if day == "saturday" or day == "sunday":
    print("It's the weekend! Time to relax.")
elif day == "friday":
    print("It's Friday! The weekend is almost here.")
elif day in ["monday", "tuesday", "wednesday", "thursday"]:
    print("It's a weekday. Time to work or study.")
# Pas de clause else - si rien ne correspond, il ne se passe rien
 
print("Have a great day!")

Si vous saisissez "holiday" :

Have a great day!

Aucune condition ne correspond, et il n’y a pas de clause else, donc seul le dernier print() s’exécute.

8.4) Instructions if imbriquées

Parfois, vous devez prendre une décision à l’intérieur d’une décision. Les instructions if imbriquées (nested if statements) placent une conditionnelle à l’intérieur d’une autre, ce qui vous permet de vérifier des conditions supplémentaires uniquement après qu’une condition initiale est satisfaite.

8.4.1) Comprendre les conditionnelles imbriquées

Les instructions if imbriquées sont puissantes parce qu’elles vous permettent d’éviter de vérifier des conditions qui n’ont pas encore de sens. Par exemple, cela ne sert à rien de demander un mot de passe si l’utilisateur n’a pas de compte. L’imbrication vous permet de structurer votre logique pour qu’elle corresponde aux processus de décision du monde réel, où certaines questions n’ont de sens qu’après que d’autres ont été répondues.

Une instruction if imbriquée est simplement une instruction if (ou une chaîne if-elif-else) à l’intérieur d’un autre bloc if :

if outer_condition:
    # Ce code s’exécute si outer_condition est True
    if inner_condition:
        # Ce code s’exécute si LES DEUX conditions sont True
        inner_block
    else:
        # Ceci s’exécute si outer_condition est True mais inner_condition est False
        inner_else_block
else:
    # Ceci s’exécute si outer_condition est False
    outer_else_block

L’instruction if interne n’est évaluée que si la condition externe est True. Cela crée une hiérarchie de décisions.

Voici un exemple simple :

# account_login.py
has_account = input("Do you have an account? (yes/no): ").lower() == "yes"
 
if has_account:
    print("Welcome back!")
    password = input("Enter your password: ")
    
    if password == "secret123":
        print("Login successful!")
        print("Access granted to your dashboard.")
    else:
        print("Incorrect password.")
        print("Access denied.")
else:
    print("Please create an account first.")
    print("Visit our registration page.")

Si vous répondez "yes" et saisissez le bon mot de passe :

Welcome back!
Login successful!
Access granted to your dashboard.

Si vous répondez "yes" mais saisissez un mauvais mot de passe :

Welcome back!
Incorrect password.
Access denied.

Si vous répondez "no" :

Please create an account first.
Visit our registration page.

Remarquez que la vérification du mot de passe ne se produit que si l’utilisateur a un compte. C’est l’avantage clé de l’imbrication — vous pouvez éviter des vérifications inutiles.

8.4.2) Quand utiliser des instructions if imbriquées

Les instructions if imbriquées sont utiles lorsque :

1. Les décisions dépendent de décisions précédentes : vous devez vérifier quelque chose seulement après qu’une autre condition est satisfaite
2. Créer des arbres de décision : chaque niveau réduit les possibilités
3. Valider des prérequis : vérifier les exigences de base avant de vérifier des exigences détaillées
4. Éviter des vérifications inutiles : ignorer des opérations coûteuses lorsque des conditions antérieures échouent

Exemple : Éligibilité à un prêt

# loan_eligibility.py
age = int(input("Enter your age: "))
 
if age >= 18:
    print("Age requirement met.")
    income = float(input("Enter your annual income: $"))
    
    if income >= 30000:
        print("Income requirement met.")
        credit_score = int(input("Enter your credit score: "))
        
        if credit_score >= 650:
            print("Congratulations! You are eligible for a loan.")
            print("Please proceed to the application form.")
        else:
            print("Sorry, your credit score is too low.")
            print("Minimum required: 650")
    else:
        print("Sorry, your income is too low.")
        print("Minimum required: $30,000")
else:
    print("Sorry, you must be 18 or older to apply.")

Cela crée un arbre de décision où chaque niveau dépend du précédent. Si l’âge est inférieur à 18 ans, nous ne demandons jamais le revenu ni le score de crédit.

8.4.3) Éviter une imbrication excessive

Même si l’imbrication est puissante, trop de niveaux rendent le code difficile à lire et à comprendre. Considérez cet exemple fortement imbriqué :

# Trop imbriqué - difficile à suivre
if condition1:
    if condition2:
        if condition3:
            if condition4:
                if condition5:
                    print("All conditions met!")

C’est difficile à lire et à maintenir. Voici des stratégies pour réduire l’imbrication :

Stratégie 1 : Combiner des conditions lorsque c’est approprié

Nous apprendrons l’opérateur and en détail au chapitre 9, mais pour l’instant, sachez simplement qu’il vous permet de vérifier plusieurs conditions à la fois :

# Mieux : utiliser 'and' pour combiner des conditions (le chapitre 9 expliquera cela complètement)
# Nous apprendrons 'and' au chapitre 9, mais pour l’instant, sachez simplement qu’il vérifie
# que toutes les conditions sont vraies
if condition1 and condition2 and condition3 and condition4 and condition5:
    print("All conditions met!")

Stratégie 2 : Utiliser des retours anticipés (lorsque vous travaillez avec des fonctions, que nous apprendrons au chapitre 19) :

# Dans une fonction, on peut retourner plus tôt
def check_eligibility(age, income, credit_score):
    if age < 18:
        return "Too young"
    if income < 30000:
        return "Income too low"
    if credit_score < 650:
        return "Credit score too low"
    return "Eligible"

Stratégie 3 : Aplatir avec elif lorsque c’est approprié :

# Au lieu d’ifs imbriqués pour vérifier des plages
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
# ... and so on

8.5) Pièges courants des instructions if (indentation, deux-points et logique)

Même les programmeurs expérimentés commettent des erreurs avec les instructions if. Cette section couvre les erreurs les plus courantes que rencontrent les débutants et comment les éviter.

8.5.1) Erreurs d’indentation

Python utilise l’indentation pour déterminer quelles instructions appartiennent à quel bloc. Une indentation incorrecte est l’une des sources d’erreurs les plus courantes.

Problème 1 : Indentation manquante

# INCORRECT - IndentationError
age = 20
 
if age >= 18:
print("You are an adult.")  # Pas indenté !

Cela produit :

  File "example.py", line 4
    print("You are an adult.")
    ^
IndentationError: expected an indented block

Solution : Indentez toujours le bloc sous une instruction if :

# CORRECT
age = 20
 
if age >= 18:
    print("You are an adult.")  # Correctement indenté

Problème 2 : Indentation incohérente

# INCORRECT - Mélange d'espaces et de tabulations, ou espaces incohérents
if temperature > 30:
    print("It's hot!")
      print("Stay hydrated!")  # Espaces supplémentaires - indentation incohérente

Solution : Utilisez une indentation cohérente (4 espaces est la norme Python) :

# CORRECT
if temperature > 30:
    print("It's hot!")
    print("Stay hydrated!")  # Même niveau d’indentation

Problème 3 : Indentation d’imbrication incorrecte

# INCORRECT - Mauvais niveau d’indentation
if has_account:
    print("Welcome!")
    if password == "correct":
    print("Login successful!")  # Devrait être plus indenté

Solution : Chaque niveau imbriqué nécessite une indentation supplémentaire :

# CORRECT
if has_account:
    print("Welcome!")
    if password == "correct":
        print("Login successful!")  # Correctement indenté pour le bloc imbriqué

8.5.2) Deux-points manquants

Les deux-points (:) à la fin des lignes if, elif et else sont obligatoires. Les oublier est une erreur très fréquente :

# INCORRECT - SyntaxError: missing colon
if age >= 18
    print("Adult")

Cela produit :

  File "example.py", line 2
    if age >= 18
                ^
SyntaxError: invalid syntax

Solution : Incluez toujours les deux-points :

# CORRECT
if age >= 18:
    print("Adult")

La même règle s’applique à elif et else :

# CORRECT - Tous les deux-points sont présents
if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
else:
    grade = "F"

8.5.3) Opérateurs de comparaison incorrects

Problème 1 : Utiliser l’affectation (=) au lieu de la comparaison (==)

# INCORRECT - Cela affecte 18 à age, ne compare pas !
age = 20
 
if age = 18:  # SyntaxError
    print("You are 18")

Solution : Utilisez == pour la comparaison :

# CORRECT
age = 20
 
if age == 18:
    print("You are 18")

8.5.4) Code inatteignable à cause d’erreurs de logique

Problème : Des conditions qui ne peuvent jamais être True

# INCORRECT - Le elif ne peut jamais s’exécuter
score = 85
 
if score >= 60:
    print("You passed!")
elif score >= 80:  # Ceci ne s’exécutera jamais !
    print("You got a B!")

Si score vaut 85, la première condition (score >= 60) est True, donc le elif n’est jamais vérifié. L’ordre est mauvais.

Solution : Ordonnez les conditions de la plus spécifique à la moins spécifique :

# CORRECT
score = 85
 
if score >= 80:
    print("You got a B!")
elif score >= 60:
    print("You passed!")

8.5.5) Blocs if vides

Vous ne pouvez pas avoir un bloc if vide en Python :

# INCORRECT - SyntaxError
if temperature > 30:
    # J’ajouterai du code ici plus tard
 
print("Done")

Cela produit :

  File "example.py", line 3
    print("Done")
    ^
IndentationError: expected an indented block

Solution : Utilisez l’instruction pass comme placeholder (abordée dans la section suivante) :

# CORRECT - Utilisation de pass comme placeholder
if temperature > 30:
    pass  # TODO: Add code here later
 
print("Done")

8.6) Utiliser pass comme placeholder dans les blocs

Parfois, en écrivant du code, vous savez que vous avez besoin d’une instruction if mais vous n’avez pas encore décidé quel code doit y aller. Python n’autorise pas les blocs de code vides, vous avez donc besoin d’un moyen de créer un bloc valide mais qui « ne fait rien ». C’est là qu’intervient l’instruction pass.

8.6.1) Qu’est-ce que pass ?

L’instruction pass est une opération nulle — lorsque Python l’exécute, il ne se passe rien. C’est un placeholder qui vous permet d’écrire du code syntaxiquement correct même lorsque vous n’avez pas encore l’implémentation.

if condition:
    pass  # Ne rien faire pour l’instant

Pensez à pass comme un moyen de dire à Python : « Je sais que j’ai besoin de code ici, mais je le compléterai plus tard. » C’est particulièrement utile pendant le développement, lorsque vous esquissez la structure de votre programme.

8.6.2) Pourquoi pass est nécessaire

Python exige au moins une instruction dans chaque bloc de code. Un bloc vide provoque une erreur de syntaxe :

# INCORRECT - Cela provoque une erreur
if age >= 18:
    # TODO: Add adult logic here
 
print("Done")

Error:

  File "example.py", line 3
    print("Done")
    ^
IndentationError: expected an indented block

L’utilisation de pass rend le code syntaxiquement valide :

# CORRECT - Utilisation de pass comme placeholder
if age >= 18:
    pass  # TODO: Add adult logic here
 
print("Done")

8.6.3) Usages courants de pass

Usage 1 : Placeholder pendant le développement

Lorsque vous définissez la structure de votre programme mais que vous n’avez pas encore tout implémenté :

# user_system.py
user_type = input("Enter user type (admin/user/guest): ").lower()
 
if user_type == "admin":
    pass  # TODO: Implement admin features
elif user_type == "user":
    pass  # TODO: Implement user features
elif user_type == "guest":
    print("Welcome, guest! Limited access granted.")
else:
    print("Invalid user type.")

Cela vous permet d’exécuter le programme et de tester les parties que vous avez déjà implémentées tout en laissant des placeholders pour le travail futur.

Usage 2 : Ne rien faire intentionnellement dans une branche

Parfois, vous voulez réellement ne rien faire dans certains cas, mais vous devez gérer d’autres cas :

# positive_numbers.py
# Ne traiter que les nombres positifs
number = int(input("Enter a number: "))
 
if number > 0:
    result = number * 2
    print(f"Double of {number} is {result}")
elif number == 0:
    pass  # Zéro est valide mais ne nécessite aucune action
else:
    print("Negative numbers are not allowed.")

8.6.4) pass dans d’autres contextes

Même si nous nous sommes concentrés sur pass dans les instructions if, vous le rencontrerez dans d’autres contextes à mesure que vous apprendrez davantage Python :

• Fonctions (functions) (chapitre 20) : placeholder pour les corps de fonctions
• Classes (chapitre 31) : placeholder pour les définitions de classes
• Boucles (loops) (chapitres 11-12) : placeholder pour les corps de boucles
• Gestionnaires d’exceptions (exception handlers) (chapitre 29) : ignorer intentionnellement des erreurs

Pour l’instant, souvenez-vous que pass est votre outil pour créer des blocs de code valides mais vides lorsque vous en avez besoin.

Tout rassembler

Dans ce chapitre, vous avez appris comment rendre vos programmes intelligents et réactifs en utilisant des instructions conditionnelles. Passons en revue les concepts clés :

Les instructions if simples exécutent du code uniquement lorsqu’une condition est vraie :

if temperature > 30:
    print("It's hot outside!")

Les instructions if-else choisissent entre deux alternatives :

if age >= 18:
    print("Adult")
else:
    print("Minor")

Les chaînes if-elif-else gèrent plusieurs options mutuellement exclusives :

if score >= 90:
    grade = "A"
elif score >= 80:
    grade = "B"
elif score >= 70:
    grade = "C"
else:
    grade = "F"

Les instructions if imbriquées permettent de prendre des décisions à l’intérieur de décisions :

if has_account:
    if password_correct:
        print("Welcome!")
    else:
        print("Wrong password")
else:
    print("Create an account")

Pièges courants à éviter :

• Oublier les deux-points après if, elif et else
• Indentation incorrecte ou incohérente
• Utiliser = au lieu de == pour la comparaison
• Mauvais ordre dans les chaînes elif
• Blocs vides sans pass

L’instruction pass sert de placeholder pour les blocs vides pendant le développement.

Vous avez maintenant les outils pour écrire des programmes qui prennent des décisions intelligentes basées sur des conditions. Dans le prochain chapitre, nous apprendrons les opérateurs de logique booléenne (boolean logic operators) (and, or, not) qui vous permettent de combiner plusieurs conditions en une logique de décision plus sophistiquée. Cela rendra vos instructions if encore plus puissantes et expressives.