Summary  
This chapter explains how to use comparison operators in Python to evaluate expressions to boolean values, covering equality and inequality checks, chained range comparisons, and direct boolean evaluations.

General domain of usage  
Fitness tracking

Lad os nu se nærmere på, hvad du faktisk kan inkludere i disse betingelser.

Sammenligningsoperatorer er nyttige til at vurdere værdierne af variabler. Resultatet er altid en boolesk værdi, som enten kan være `True` eller `False`. 

Der er to lighedstegn her, fordi et enkelt lighedstegn (`=<`) har en helt anden betydning. Det bruges til tildeling og kan ikke (og giver ikke mening at) bruges i `if`-blokke.

Bemærk

Du kan sammenligne komplekse matematiske udtryk, elementer fra forskellige datastrukturer, strenge og endda booleske værdier. Da vi allerede ved, hvordan man sammenligner tal fra tidligere kapitler, lad os udforske andre typer sammenligninger:

#### Eksempel 1: Sammenligning af strenge for at bestemme træningstyper

favorite_activity = "Yoga"
current_activity = "Running"

if favorite_activity != current_activity:
    print("This is not your favorite activity, but keep going!")

Dette tjekker, om to strenge ikke er ens (præcis match, store og små bogstaver betyder noget).
#### Eksempel 2: Sammenligning af booleske værdier for at kontrollere aktivitetsfuldførelse

# Check if the user completed their morning routine
morning_run_completed = True

if morning_run_completed:
    print("Great job on completing your morning run!")

Dette eksempel vurderer, om en bestemt aktivitet er blevet gennemført (i dette tilfælde en morgentur). I stedet for at skrive `if morning_run_completed == True`, bruger vi `if morning_run_completed`, fordi værdien af `morning_run_completed` allerede er en boolesk værdi (True eller False). At skrive `== True` er overflødigt og mindre præcist. Python tillader sådanne forenklinger for at gøre koden mere overskuelig og lettere at læse.
#### Eksempel 3: Kontrol af om et tal ligger inden for et interval
Din app kan hjælpe brugere med at holde styr på deres fysiske aktivitet. Denne opgave kontrollerer, om brugerens daglige skridttal ligger inden for et anbefalet interval og giver feedback på deres fremskridt.

daily_steps = 7500

# Step count range check
if 5000 <= daily_steps <= 10000:
    print("You're on track with your step count!")

Dette eksempel demonstrerer en kædet sammenligning for at kontrollere, om en numerisk værdi ligger inden for et bestemt interval.
I stedet for at skrive:</br>
`if daily_steps >= 5000 and daily_steps <= 10000:`</br>
kan du forenkle det ved at bruge en kædet sammenligning for bedre klarhed og kortfattethed:</br>
`if 5000 <= daily_steps <= 10000`.</br>
Undgå at gøre intervalkontroller unødigt komplicerede—brug kædning, når det er muligt, for at holde din kode mere overskuelig og letlæselig.

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

# 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_variables_declared(self):
        """Check if all required variables are declared."""
        variables = ['street_temperature', 'hydration_goal_met', 'running_temp']
        missing_vars = [var for var in variables if not hasattr(user_code, var)]
        
        _dynamic_test(
            self,
            not missing_vars,
            "All required variables are declared.",
            f"Missing variable(s): {', '.join(missing_vars)}."
        )

    def test_variables_types(self):
        """Check if variables have the correct data types."""
        expected_types = {
            'street_temperature': int,
            'hydration_goal_met': bool,
            'running_temp': bool
        }
        incorrect_types = {
            var: type(getattr(user_code, var)) 
            for var in expected_types if not isinstance(getattr(user_code, var), expected_types[var])
        }

        _dynamic_test(
            self,
            not incorrect_types,
            "All variables have the correct data types.",
            f"Incorrect data types detected: {incorrect_types}."
        )

    def test_running_temp_logic(self):
        """Check if `running_temp` is set correctly based on `street_temperature`."""
        expected_value = 10 <= user_code.street_temperature <= 20
        _dynamic_test(
            self,
            user_code.running_temp == expected_value,
            f"The `running_temp` variable is correctly set to {expected_value} when `street_temperature` is {user_code.street_temperature}.",
            f"Incorrect value for `running_temp`. Expected {expected_value} when `street_temperature` is {user_code.street_temperature}, but got {user_code.running_temp}."
        )

    def test_hydration_goal_condition_used(self):
        """Ensure `if hydration_goal_met:` is correctly used."""
        with open("user_code.py", "r") as f:
            user_code_source = f.read()

        correct_condition = (
          re.search(r'if\s+hydration_goal_met\s*:', user_code_source) or
          re.search(r'if\s+hydration_goal_met\s*==\s*True\s*:', user_code_source) or
          re.search(r'if\s+hydration_goal_met\s*!=\s*False\s*:', user_code_source)
        )

        _dynamic_test(
            self,
            correct_condition,
            "The correct condition `if hydration_goal_met:` is used.",
            "Expected the condition `if hydration_goal_met:`, but it was not found."
        )

    def test_if_statements_used(self):
        """Check if `if` statements are used in the code."""
        with open("user_code.py", "r") as f:
            user_code_source = f.read()

        if_found = re.search(r'^\s*if\s+.*:', user_code_source, re.MULTILINE) is not None

        _dynamic_test(
            self,
            if_found,
            "At least one `if` statement is used in the code.",
            "Expected at least one `if` statement in the code, but none were found."
        )

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.

Brug af Sammenligningsoperatorer i Python

Eksempel 1: Sammenligning af strenge for at bestemme træningstyper

Eksempel 2: Sammenligning af booleske værdier for at kontrollere aktivitetsfuldførelse

Eksempel 3: Kontrol af om et tal ligger inden for et interval

Løsning