Summary  
This chapter covers the Boolean data type and how comparison operators (==, !=, >, <, >=, <=) produce True or False values to enable decision-making in code.

General domain of usage  
Inventory management (e.g., checking if an item is low in stock)

I dette kapittelet skal vi dykke ned i `Boolean` datatypen. Booleans er enkle, men kraftige, de lar oss håndtere `True` eller `False` verdier, slik at programmene våre kan **reagere på forskjellige situasjoner** effektivt. I konteksten av å drive en dagligvarebutikk, kan Booleans hjelpe oss med å avgjøre om visse betingelser er oppfylt, for eksempel om en vare er på lager eller om et salg er aktivt.

Se hvordan Alex bruker `Boolean` datatyper for å sammenligne priser og navn:


## Forståelse av Boolsk Datatype

En **boolsk** datatype har kun to mulige verdier: `True` og `False`. Disse verdiene er **ofte resultatet av sammenligningsoperasjoner** og er grunnleggende for å kontrollere flyten i programmene våre. Ved å forstå boolske verdier, vil du kunne skrive kode som kan **ta beslutninger basert på ulike betingelser**.

Følgende operasjoner er vanlige **sammenligningsoperatorer som resulterer i boolske verdier**:


- **Lik med**: `==`;
- **Ikke lik med**: `!=`;
- **Større enn**: `>`;
- **Mindre enn**: `<`;
- **Større enn** eller **lik med**: `>=`;
- **Mindre enn** eller **lik med**: `<=`.

### Eksempelapplikasjon

La oss sjekke om en vare (`milk`) er **lav på lager** ved å sammenligne mengden med en forhåndsdefinert terskel for lavt lager:


# Define the quantity of the item and the low stock threshold
milk_quantity = 12
low_stock_threshold = 10

# Check if the item quantity is below the low stock threshold
low_stock = milk_quantity <= low_stock_threshold

# Print the result
print("Is the item low in stock?", low_stock)

Nå er det din tur til å øve på å bruke **boolske**. I denne utfordringen skal du sjekke om den totale kostnaden av et kjøp er kvalifisert for rabatt.

import unittest
import importlib
import io
from contextlib import redirect_stdout
import re
import inspect
import user_code


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)


def strip_comments_from_source(module):
    try:
        source = inspect.getsource(module)
        lines = source.split('\\n')
        cleaned = []
        for line in lines:
            stripped = line.strip()
            if stripped.startswith('#'):
                continue
            if '#' in line:
                line = line.split('#')[0]
            if line.strip():
                cleaned.append(line)
        return '\\n'.join(cleaned)
    except Exception:
        return ""


class TestDiscountEligibility(unittest.TestCase):

    def normalize_text(self, text):
        text = text.lower()
        text = re.sub(r'\s+', ' ', text)  # Replace multiple spaces/newlines with single space
        text = re.sub(r'\s*([,:?])\s*', r'\1 ', text)  # Normalize punctuation spacing
        return text.strip()

    def test_total_cost_value(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'total_cost') and user_code.total_cost == 25.00,
            "total_cost is defined correctly with value 25.00",
            f"Expected total_cost to be 25.00, got {getattr(user_code, 'total_cost', None)}"
        )

    def test_discount_eligibility_value(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'discountEligible') and user_code.discountEligible is True,
            "discountEligible is correctly True when total_cost >= 20.00",
            f"Expected discountEligible to be True, got {getattr(user_code, 'discountEligible', None)}"
        )

    def test_discount_comparison_operator_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            re.search(r'>=', source) is not None,
            ">= operator used to compare total_cost to 20.00",
            "Expected usage of >= operator to compare total_cost and 20.00"
        )

    def test_print_output_format(self):
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = self.normalize_text(f.getvalue())
        expected = self.normalize_text("Is the purchase eligible for a discount? True")
        _dynamic_test(
            self,
            expected in output,
            "Print output is correct and formatted as required",
            f"Expected print output to match: '{expected}', but got: '{output}'"
        )


if __name__ == '__main__':
    unittest.main()


test_main.py

Python er et høynivå, tolket, generelt programmeringsspråk. I motsetning til språk som HTML, CSS og JavaScript, som hovedsakelig brukes i webutvikling, har Python allsidighet på tvers av flere domener, inkludert programvareutvikling, datavitenskap og back-end utvikling. Dette kurset vil veilede deg gjennom Pythons grunnleggende konsepter, og utstyre deg med ferdighetene til å lage dine egne funksjoner ved slutten av programmet.

I denne delen vil du utforske det grunnleggende i Python, bli kjent
med arbeidsområdet ditt, utføre enkle matematiske operasjoner og vise funnene dine.

I denne delen vil du oppdage hvordan du kan lagre elementer som tall og tekst
i datamaskinens minne og hente dem ved navn. I tillegg vil du få en introduksjon til tekst
manipulering i Python.

I denne seksjonen vil du utforske den boolske datatypen og lære hvordan den brukes
til å utvikle programmer som reagerer på visse betingelser.

I denne delen vil du fortsette å lære om datatyper og oppdage
hvordan du kan organisere ulike attributter i en enkelt variabel ved hjelp av lists, tuples, og dictionaries.

I denne seksjonen vil du lære hvordan du lager løkker i Python — en essensiell ferdighet
for å iterere gjennom lister, tupler og dictionaries.

For å avslutte dette innledende kurset, vil du utforske noen innebygde
funksjoner og deretter begynne å utvikle dine egne!

Boolsk Datatype

Forståelse av Boolsk Datatype

Eksempelapplikasjon

Output Krav

Løsning