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`-**setningen** er et grunnleggende verktøy i Python som lar oss ta beslutninger i koden vår.

Her er hovedkomponentene i syntaksen for if-setningen:
- **Nøkkelord** `if`: dette nøkkelordet starter den betingede setningen. Husk at det er store- og småbokstavfølsomt—bruk av `If` i stedet for `if` vil føre til en feil;
- **Betingelse**: betingelsen er et uttrykk som evalueres til `True` eller `False`. I dette eksempelet sjekker vi om en variabel oppfyller et bestemt krav;
- **Kolon** `:`: kolonet markerer at den følgende innrykkede blokken tilhører `if`-setningen;
- **Innrykket kodeblokk**: denne blokken inneholder koden som kun kjøres hvis betingelsen er `True`.

#### Eksempel 1: Standard utfø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` sjekker om antall skritt som er tatt er mindre enn dagens mål;
2. Hvis betingelsen er **True**, kjøres koden inne i `if`-blokken;
3. Meldingen bruker en **f-streng** for å dynamisk vise antall skritt som gjenstår, noe som gjør utdataene brukervennlige og presise.

**f-strenger** gjør det mulig å sette inn uttrykk i en streng ved å bruke krøllparenteser `{}`, for enklere og mer lesbar strengformatering. For å lage en f-streng, sett `f` foran strengen.
For eksempel: `f"Your goal is {step_goal} steps"`.

Merk

#### Eksempel 2: Når ingenting blir utført

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 tilfellet evalueres betingelsen `steps_taken < step_goal` til `False` fordi `steps_taken` er lik `step_goal`. Siden betingelsen ikke er oppfylt, blir ikke kodeblokken inne i `if`-setningen kjørt, og ingenting skrives ut til konsollen. Dette viser at koden kun kjøres når betingelsen evalueres til `True`.

Bildet viser flyten i en if-setning:
- **Betingelsessjekk**: programmet vurderer om betingelsen er `True` eller `False`;
- **Utførelse**: hvis betingelsen er `True`, kjøres den innrykkede kodeblokken. Ellers hopper programmet over den.

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

Utforsk nyansene ved den betingede if-else-operatøren i Python gjennom klare forklaringer og praktiske eksempler. Styrk forståelsen din med praktiske oppgaver som forsterker hvert konsept, og oppdag hvordan du bruker if-elif-else-setninger effektivt for mer komplekse beslutningsprosesser.

Oppdag allsidigheten til den betingede if-operatøren og dens evne til å forme programresultater. Fordyp deg i logiske operatorer, mestre deres praktiske bruk, og lær hvordan du prioriterer dem effektivt for å skrive tydelig og effektiv kode.

Lær hvordan du tar beslutninger basert på betingelser, forenkler koden ved å bruke else-nøkkelordet, og forbedrer både effektivitet og lesbarhet. Lås opp effektiviteten til én-linjers beslutninger med den ternære operatoren!

Oppdag den mest avanserte formen for betingede setninger: if-elif-else. Bli kjent med syntaksen og lær hvordan du bruker denne konstruksjonen riktig for å håndtere flere beslutningsscenarier i programmene dine.

Syntaks for if-setning i Python

Eksempel 1: Standard utførelse

Forklaring

Eksempel 2: Når ingenting blir utført

Løsning