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

La oss nå se nærmere på hva du faktisk kan inkludere i slike betingelser.

Sammenligningsoperatorer er nyttige for å vurdere verdiene til variabler. Resultatet deres er alltid en boolsk verdi, som kan være enten `True` eller `False`. 

Det er to likhetstegn her fordi et enkelt likhetstegn (`=<`) har en helt annen betydning. Det brukes til tildeling og kan ikke (og gir ikke mening) å bruke i `if`-blokker.

Merk

Du kan sammenligne komplekse matematiske uttrykk, elementer fra ulike datastrukturer, strenger og til og med boolske verdier. Siden vi allerede har lært å sammenligne tall i tidligere kapitler, skal vi nå utforske andre typer sammenligninger:

#### Eksempel 1: Sammenligne strenger for å avgjøre treningstype

favorite_activity = "Yoga"
current_activity = "Running"

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

Dette sjekker om to strenger ikke er like (eksakt samsvar, skiller mellom store og små bokstaver).
#### Eksempel 2: Sammenligne boolske verdier for å sjekke om aktiviteten er fullført

# 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 eksemplet vurderer om en spesifikk aktivitet er fullført (i dette tilfellet en morgentur). I stedet for å skrive `if morning_run_completed == True`, bruker vi `if morning_run_completed` fordi verdien til `morning_run_completed` allerede er en boolsk verdi (True eller False). Å skrive `== True` er overflødig og mindre konsist. Python tillater slike forenklinger for å gjøre koden renere og lettere å lese.
#### Eksempel 3: Sjekke om et tall er innenfor et område
Appen din kan hjelpe brukere med å spore fysisk aktivitet. Denne oppgaven sjekker om brukerens daglige antall skritt er innenfor et anbefalt område og gir tilbakemelding på fremdriften.

daily_steps = 7500

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

Dette eksemplet viser en kjedet sammenligning for å sjekke om en numerisk verdi faller innenfor et bestemt område.
I stedet for å skrive:</br>
`if daily_steps >= 5000 and daily_steps <= 10000:`</br>
kan du forenkle det ved å bruke en kjedet sammenligning for bedre klarhet og korthet:</br>
`if 5000 <= daily_steps <= 10000`.</br>
Unngå å gjøre områdesjekker unødvendig kompliserte—bruk kjeding når det er mulig for å holde koden din renere og lettere å lese.

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

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.

Bruk av sammenligningsoperatorer i Python

Eksempel 1: Sammenligne strenger for å avgjøre treningstype

Eksempel 2: Sammenligne boolske verdier for å sjekke om aktiviteten er fullført

Eksempel 3: Sjekke om et tall er innenfor et område

Løsning