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

`if`-**sætningen** er et grundlæggende værktøj i Python, der gør det muligt at træffe beslutninger i koden.

Her er de vigtigste elementer i if-sætningens syntaks:
- **Nøgleord** `if`: dette nøgleord indleder den betingede sætning. Bemærk, at det er case-sensitivt—hvis du bruger `If` i stedet for `if`, vil det give en fejl;
- **Betingelse**: betingelsen er et udtryk, der evalueres til `True` eller `False`. I dette eksempel kontrolleres det, om en variabel opfylder et bestemt krav;
- **Kolon** `:`: kolonet angiver, at det følgende indrykkede blok hører til `if`-sætningen;
- **Indrykket kodeblok**: denne blok indeholder koden, der kun køres, hvis betingelsen er `True`.

#### Eksempel 1: Standardudførelse

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

### Forklaring

1. **Betingelsen** `steps_taken < step_goal` kontrollerer, om antallet af skridt er mindre end det daglige mål;
2. Hvis betingelsen er **True**, udføres koden inde i `if`-blokken;
3. Beskeden bruger en **f-string** til dynamisk at inkludere det resterende antal skridt, hvilket gør outputtet brugervenligt og præcist.

**f-strenge** muliggør indlejring af udtryk i en streng ved at bruge krøllede parenteser `{}`, hvilket gør strengformatering nemmere og mere læsbar. For at oprette en f-streng, skal strengen indledes med `f`.
For eksempel: `f"Your goal is {step_goal} steps"`.

Bemærk

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

I dette tilfælde evalueres betingelsen `steps_taken < step_goal` til `False`, fordi `steps_taken` er lig med `step_goal`. Da betingelsen ikke er opfyldt, bliver kodeblokken inde i `if`-sætningen ikke udført, og der udskrives intet til konsollen. Dette demonstrerer, at koden kun køres, når betingelsen evalueres til `True`.

Billedet viser flowet i en if-sætning:
- **Betingelsestjek**: programmet evaluerer, om betingelsen er `True` eller `False`;
- **Udførelse**: hvis betingelsen er `True`, køres den indrykkede kodeblok. Ellers springer programmet den 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

Udforsk nuancerne i den betingede if-else-operator i Python gennem klare forklaringer og praktiske eksempler. Styrk din forståelse med praktiske opgaver, der understøtter hvert koncept, og opdag hvordan du effektivt bruger if-elif-else-sætninger til mere kompleks beslutningstagning.

Opdag alsidigheden ved den betingede if-operator og dens evne til at forme programresultater. Dyk ned i verdenen af logiske operatorer, opnå fortrolighed med deres praktiske anvendelse, og lær at prioritere dem effektivt for at skrive klar og effektiv kode.

Lær at træffe beslutninger baseret på betingelser, forenkle kode ved hjælp af else-nøgleordet, hvilket forbedrer både effektivitet og læsbarhed. Opnå effektivitet med énliniers beslutninger ved hjælp af den ternære operator!

Opdag den mest avancerede form for betingede udsagn: if-elif-else. Bliv fortrolig med syntaksen og lær, hvordan denne konstruktion anvendes korrekt til at håndtere flere beslutningsscenarier i dine programmer.

Syntaks for Python If-sætning

Eksempel 1: Standardudførelse

Forklaring

Eksempel 2: Når intet udføres

Løsning