Dit supermarkeds system er designet til at spore lagerbeholdningen af varer på forskellige hylder ved hjælp af **tupler**, da tupler sikrer, at dataene er **uforanderlige** efter oprettelse.

Butikken skal dog **overvåge bestemte varer** og spore deres mængder eller placeringer for at hjælpe med genopfyldning eller omorganisering.

Opgaven er at analysere og administrere lagerdata ved hjælp af tupler for at bestemme visse målinger og træffe beslutninger baseret på specifikke kriterier.

import unittest
import importlib
import io
import re
from contextlib import redirect_stdout
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 TestFruitShelfTuple(unittest.TestCase):

    def normalize_text(self, text):
        text = text.lower()
        text = re.sub(r'\s+', ' ', text)
        text = re.sub(r'\s*([,:?\[\]\(\)])\s*', r'\1', text)
        return text.strip()

    def test_apple_count(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'apple_count') and user_code.apple_count == 3,
            "apple_count is correct (3)",
            f"Expected apple_count to be 3, got {getattr(user_code, 'apple_count', None)}"
        )

    def test_banana_index(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'banana_index') and user_code.banana_index == 2,
            "banana_index is correct (2)",
            f"Expected banana_index to be 2, got {getattr(user_code, 'banana_index', None)}"
        )

    def test_grape_count_logic(self):
        importlib.reload(user_code)
        grape_count = user_code.shelf.count("grapes")
        _dynamic_test(
            self,
            grape_count == 1,
            "grape_count is correct and equals 1",
            f"Expected grape count to be 1, got {grape_count}"
        )

    def test_oranges_in_shelf(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            "oranges" in user_code.shelf,
            "'oranges' is present in shelf",
            "'oranges' expected in shelf, but not found"
        )

    def test_print_output(self):
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = self.normalize_text(f.getvalue())

        expected_fragments = [
            self.normalize_text("Number of Apples: 3"),
            self.normalize_text("First Banana Index: 2"),
            self.normalize_text("Apples need to be restocked."),
            self.normalize_text("Grapes need to be restocked."),
            self.normalize_text("Oranges are at index: 1"),
        ]

        for expected in expected_fragments:
            _dynamic_test(
                self,
                expected in output,
                f"Output includes: {expected}",
                f"Expected output to include '{expected}', but got: '{output}'"
            )

    def test_in_operator_used(self):
        source = strip_comments_from_source(user_code)
        found = re.search(r'\s+in\s+', source)
        _dynamic_test(
            self,
            found is not None,
            "'in' operator is used to check for 'oranges'",
            "Expected use of 'in' to check for 'oranges'"
        )


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

test_main.py

Python er et højniveau, fortolket, generelt anvendeligt programmeringssprog. I modsætning til sprog som HTML, CSS og JavaScript, der primært anvendes til webudvikling, udmærker Python sig ved sin alsidighed på tværs af flere domæner, herunder softwareudvikling, datavidenskab og back-end udvikling. Dette kursus vil guide dig gennem Pythons grundlæggende koncepter og give dig færdighederne til at oprette dine egne funktioner ved programmets afslutning.

I dette afsnit vil du udforske grundlæggende Python, blive fortrolig med dit arbejdsområde, udføre simple matematiske operationer og vise dine resultater.

I dette afsnit vil du lære, hvordan man gemmer elementer såsom tal og tekst
i computerens hukommelse og henter dem ved navn. Derudover får du en introduktion til tekstmanipulation i Python.

I dette afsnit vil du udforske den booleske datatypen og lære, hvordan den anvendes til at udvikle programmer, der reagerer på bestemte betingelser.

I dette afsnit fortsætter du med at lære om datatyper og opdager,
hvordan man organiserer forskellige attributter i en enkelt variabel ved hjælp af lister, tupler og ordbøger.

I dette afsnit lærer du, hvordan man opretter løkker i Python — en essentiel færdighed til at iterere gennem lister, tupler og ordbøger.

For at afslutte dette introduktionskursus vil du udforske nogle indbyggede funktioner og derefter begynde at udvikle dine egne.

Hvordan kan du tilgå det tredje element i denne liste?

Hvad vil resultatet af denne kode være?



Hvordan ville du ændre "green" til "yellow"?

Udfordring: Tuple-Operationer

Løsning

Udfordring: Tuple-Operationer

Løsning