Summary
This chapter covers defining and using Python if statements to conditionally execute an indented code block based on a Boolean expression.

General domain of usage
Fitness tracking applications

L’**instruction** `if` est un outil fondamental en Python qui permet de prendre des décisions dans le code.

Voici les éléments clés de la syntaxe de l’instruction if :
- **Mot-clé** `if` : ce mot-clé commence l’instruction conditionnelle. Attention, il est sensible à la casse—utiliser `If` au lieu de `if` provoquera une erreur ;
- **Condition** : la condition est une expression qui s’évalue à `True` ou `False`. Dans cet exemple, on vérifie si une variable répond à un certain critère ;
- **Deux-points** `:` : les deux-points indiquent que le bloc indenté suivant appartient à l’instruction `if` ;
- **Bloc de code indenté** : ce bloc contient le code qui s’exécute uniquement si la condition est `True`.

#### Exemple 1 : Exécution standard

steps_taken = 7500
step_goal = 10000

if steps_taken < step_goal:
    print(f"Keep going! You need {step_goal - steps_taken} more steps to reach your goal.")

### Explication

1. La **condition** `steps_taken < step_goal` vérifie si le nombre de pas effectués est inférieur à l’objectif quotidien ;
2. Si la condition est **True**, le code à l’intérieur du bloc `if` est exécuté ;
3. Le message utilise une **f-string** pour inclure dynamiquement le nombre de pas restants, rendant la sortie conviviale et précise.

**Les f-strings** permettent d'intégrer des expressions à l'intérieur d'une chaîne de caractères, en utilisant des accolades `{}`, pour un formatage de chaîne plus simple et plus lisible. Pour créer une f-string, il faut préfixer la chaîne avec `f`.
Par exemple : `f"Your goal is {step_goal} steps"`.

Remarque

#### Exemple 2 : Lorsque rien n'est exécuté

steps_taken = 10000
step_goal = 10000

if steps_taken < step_goal:
    print(f"Keep going! You need {step_goal - steps_taken} more steps to reach your goal.")

Dans ce cas, la condition `steps_taken < step_goal` est évaluée à `False` car `steps_taken` est égal à `step_goal`. Puisque la condition n'est pas remplie, le bloc de code à l'intérieur de l'instruction `if` n'est pas exécuté et rien n'est affiché dans la console. Cela montre que le code ne s'exécute que lorsque la condition est évaluée à `True`.

L'image illustre le déroulement d'une instruction if :
- **Vérification de la condition** : le programme évalue si la condition est `True` ou `False` ;
- **Exécution** : si la condition est `True`, le bloc de code indenté s'exécute. Sinon, le programme l'ignore.

import unittest
import importlib
import user_code  # Import user's solution
import re

# Helper function for dynamic test naming and assertions
def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestUserCode(unittest.TestCase):

    def test_calories_burned_is_declared(self):
        """Check if `calories_burned` is declared."""
        _dynamic_test(
            self,
            hasattr(user_code, 'calories_burned'),
            "The `calories_burned` variable is declared.",
            "Expected `calories_burned` to be declared."
        )

    def test_calories_burned_is_integer(self):
        """Check if `calories_burned` is an integer."""
        _dynamic_test(
            self,
            isinstance(user_code.calories_burned, int),
            "The `calories_burned` variable is an integer.",
            "`calories_burned` should be an integer."
        )

    def test_calories_goal_is_declared(self):
        """Check if `calories_goal` is declared."""
        _dynamic_test(
            self,
            hasattr(user_code, 'calories_goal'),
            "The `calories_goal` variable is declared.",
            "Expected `calories_goal` to be declared."
        )

    def test_calories_goal_is_integer(self):
        """Check if `calories_goal` is an integer."""
        _dynamic_test(
            self,
            isinstance(user_code.calories_goal, int),
            "The `calories_goal` variable is an integer.",
            "`calories_goal` should be an integer."
        )

    def test_calories_goal_met_is_declared(self):
        """Check if `calories_goal_met` is declared."""
        _dynamic_test(
            self,
            hasattr(user_code, 'calories_goal_met'),
            "The `calories_goal_met` variable is declared.",
            "Expected `calories_goal_met` to be declared."
        )

    def test_calories_goal_met_is_boolean(self):
        """Check if `calories_goal_met` is a boolean."""
        _dynamic_test(
            self,
            isinstance(user_code.calories_goal_met, bool),
            "The `calories_goal_met` variable is a boolean.",
            "`calories_goal_met` should be a boolean."
        )

    def test_calories_goal_met_condition(self):
        """Check if the correct comparison operator (`>=` or `<=`) is used to update `calories_goal_met`."""
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()  # Read the source code of user_code.py
        
        correct_condition = (
            re.search(r'burned\s*>=', user_code_source) or
            re.search(r'<=\s*calories_burned', user_code_source)
        )

        _dynamic_test(
            self,
            correct_condition is not None,
            "The correct comparison operator (`>=` or `<=`) is used in the condition updating `calories_goal_met`.",
            "Expected `>=` or `<=` to be used in the condition updating `calories_goal_met`, but it was not found."
        )

    def test_if_statement_used(self):
        """Check if an `if` statement is used in the code."""
        with open('user_code.py', 'r') as file:
            user_code_source = file.read()  # Read the source code of user_code.py

        _dynamic_test(
            self,
            re.search(r'if\s+', user_code_source) is not None,
            "An `if` statement is used in the code.",
            "Expected an `if` statement in the code, but none was found."
        )


# Run the tests when executing the script
if __name__ == "__main__":
    unittest.main()

test_main.py

Explorez les subtilités de l'opérateur conditionnel if-else en Python à travers des explications claires et des exemples pratiques. Renforcez votre compréhension grâce à des exercices pratiques qui consolident chaque concept, et découvrez comment utiliser efficacement les instructions if-elif-else pour une prise de décision plus complexe.

Découvrez la polyvalence de l'opérateur conditionnel if et sa capacité à influencer les résultats d'un programme. Plongez dans l'univers des opérateurs logiques, maîtrisez leur application pratique et apprenez à les hiérarchiser efficacement pour écrire un code clair et performant.

Apprenez à prendre des décisions basées sur des conditions, à simplifier le code en utilisant le mot-clé else, améliorant ainsi à la fois l'efficacité et la lisibilité. Découvrez l'efficacité des décisions en une seule ligne avec l'opérateur ternaire !

Découvrez la forme la plus avancée des instructions conditionnelles : if-elif-else. Familiarisez-vous avec sa syntaxe et apprenez à appliquer cette construction correctement pour gérer plusieurs scénarios de prise de décision dans vos programmes.

Syntaxe de l'instruction If en Python

Exemple 1 : Exécution standard

Explication

Exemple 2 : Lorsque rien n'est exécuté

Solution