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

De `if`-**instructie** is een fundamenteel hulpmiddel in Python waarmee beslissingen in de code kunnen worden genomen.

Hier volgt een overzicht van de belangrijkste onderdelen van de if-instructiesyntax:
- **Trefwoord** `if`: dit trefwoord begint de voorwaardelijke instructie. Let op: het is hoofdlettergevoelig—gebruik van `If` in plaats van `if` veroorzaakt een fout;
- **Voorwaarde**: de voorwaarde is een expressie die evalueert naar `True` of `False`. In dit voorbeeld wordt gecontroleerd of een variabele aan een bepaalde eis voldoet;
- **Dubbele punt** `:`: de dubbele punt geeft aan dat het volgende inspringende blok bij de `if`-instructie hoort;
- **Ingesprongen codeblok**: dit blok bevat de code die alleen wordt uitgevoerd als de voorwaarde `True` is.

#### Voorbeeld 1: Standaarduitvoering

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.")

### Uitleg

1. De **voorwaarde** `steps_taken < step_goal` controleert of het aantal gezette stappen lager is dan het dagelijkse doel;
2. Als de voorwaarde **True** is, wordt de code binnen het `if`-blok uitgevoerd;
3. Het bericht gebruikt een **f-string** om het resterende aantal stappen dynamisch weer te geven, waardoor de uitvoer gebruiksvriendelijk en nauwkeurig is.

**f-strings** maken het mogelijk om expressies in een string op te nemen met behulp van accolades `{}`, voor eenvoudigere en beter leesbare stringopmaak. Om een f-string te maken, plaats je een `f` voor de string.
Bijvoorbeeld: `f"Your goal is {step_goal} steps"`.

Opmerking

#### Voorbeeld 2: Wanneer er niets wordt uitgevoerd

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.")

In dit geval evalueert de voorwaarde `steps_taken < step_goal` naar `False` omdat `steps_taken` gelijk is aan `step_goal`. Omdat aan de voorwaarde niet wordt voldaan, wordt het codeblok binnen de `if`-instructie niet uitgevoerd en wordt er niets naar de console geprint. Dit toont aan dat de code alleen wordt uitgevoerd wanneer de voorwaarde naar `True` evalueert.

De afbeelding toont het verloop van een if-instructie:
- **Voorwaarde controleren**: het programma evalueert of de voorwaarde `True` of `False` is;
- **Uitvoering**: als de voorwaarde `True` is, wordt het ingesprongen codeblok uitgevoerd. Anders slaat het programma dit over.

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

Ontdek de nuances van de conditionele if-else-operator in Python aan de hand van duidelijke uitleg en praktische voorbeelden. Versterk je begrip met praktische opdrachten die elk concept ondersteunen, en leer hoe je if-elif-else-verklaringen effectief gebruikt voor complexere besluitvorming.

Ontdek de veelzijdigheid van de conditionele if-operator en het vermogen om programmauitkomsten te beïnvloeden. Verdiep je in de wereld van logische operatoren, beheers hun praktische toepassing en leer hoe je deze effectief prioriteert om duidelijke en efficiënte code te schrijven.

Leer hoe u beslissingen neemt op basis van voorwaarden, code vereenvoudigt met behulp van het else-keyword, en zowel de efficiëntie als de leesbaarheid verbetert. Ontgrendel de efficiëntie van éénregelige beslissingen met de ternary-operator!

Ontdek de meest geavanceerde vorm van conditionele statements: if-elif-else. Maak kennis met de syntaxis en leer hoe je deze constructie correct toepast om meerdere beslissingsscenario's in je programma's te verwerken.

Python If Statement Syntaxis

Voorbeeld 1: Standaarduitvoering

Uitleg

Voorbeeld 2: Wanneer er niets wordt uitgevoerd

Oplossing