I denna utmaning kommer du att **hantera de dagliga lagernivåerna** av viktiga livsmedelsbutiksprodukter under en vecka. Genom att använda `range()`-funktionen i kombination med `len()`-funktionen kommer du att simulera försäljningspåverkan på lagret.


import unittest
import importlib
import io
import re
import inspect
from contextlib import redirect_stdout
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 TestStockProcessing(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_apples_final_stock(self):
        importlib.reload(user_code)
        result = user_code.products[0]
        _dynamic_test(
            self,
            result == ["Apples", 170],
            "Final stock for Apples is correctly updated to 170",
            f"Expected ['Apples', 170], got {result}"
        )

    def test_bananas_final_stock(self):
        importlib.reload(user_code)
        result = user_code.products[1]
        _dynamic_test(
            self,
            result == ["Bananas", 225],
            "Final stock for Bananas is correctly updated to 225",
            f"Expected ['Bananas', 225], got {result}"
        )

    def test_oranges_final_stock(self):
        importlib.reload(user_code)
        result = user_code.products[2]
        _dynamic_test(
            self,
            result == ["Oranges", 110],
            "Final stock for Oranges is correctly updated to 110",
            f"Expected ['Oranges', 110], got {result}"
        )

    def test_mangoes_final_stock(self):
        importlib.reload(user_code)
        result = user_code.products[3]
        _dynamic_test(
            self,
            result == ["Mangoes", 150],
            "Final stock for Mangoes is correctly updated to 150",
            f"Expected ['Mangoes', 150], got {result}"
        )

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

        expected_lines = [
            "Stock after sales for Apples: 120 units",
            "Stock after sales for Bananas: 155 units",
            "Stock after sales for Oranges: 80 units",
            "Stock after sales for Mangoes: 110 units",
            "Stock after shipment for Apples: 170 units",
            "Stock after shipment for Bananas: 225 units",
            "Stock after shipment for Oranges: 110 units",
            "Stock after shipment for Mangoes: 150 units",
            "Final stock levels for all products: [['Apples', 170], ['Bananas', 225], ['Oranges', 110], ['Mangoes', 150]]"
        ]

        for line in expected_lines:
            expected = self.normalize_text(line)
            _dynamic_test(
                self,
                expected in output,
                f"Output includes line: {line}",
                f"Expected output: '{line}' not found."
            )

    def test_two_for_loops_with_range(self):
        source = strip_comments_from_source(user_code)
        loops = re.findall(r'for\s+\w+\s+in\s+range\s*\(', source)
        _dynamic_test(
            self,
            len(loops) >= 2,
            "Code uses two for loops with range() as required",
            f"Expected 2 for loops with range(), found {len(loops)}"
        )


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


test_main.py

Python är ett högnivå, tolkat, allmänt programmeringsspråk. Till skillnad från språk som HTML, CSS och JavaScript, som huvudsakligen används inom webbutveckling, har Python mångsidighet över flera domäner, inklusive mjukvaruutveckling, datavetenskap och back-end utveckling. Denna kurs kommer att guida dig genom Pythons grundläggande koncept och utrusta dig med färdigheter för att skapa dina egna funktioner vid programmets slut.

I det här avsnittet kommer du att utforska grunderna i Python, bekanta dig
med din arbetsyta, utföra enkla matematiska operationer och visa dina resultat.

I det här avsnittet kommer du att upptäcka hur du sparar objekt som siffror och text
i datorns minne och hämtar dem med namn. Dessutom får du en introduktion till text
manipulation i Python.

I det här avsnittet kommer du att utforska datatypen boolean och lära dig hur den används
för att utveckla program som reagerar på vissa villkor.

I denna sektion kommer du att fortsätta lära dig om datatyper och upptäcka
hur man organiserar olika attribut i en enda variabel med hjälp av lists, tuples och dictionaries.

I det här avsnittet kommer du att lära dig hur man skapar loopar i Python — en viktig färdighet
för att iterera genom listor, tupler och dictionaries.

För att avsluta denna introduktionskurs kommer du att utforska några inbyggda
funktioner och sedan börja utveckla dina egna!

Utmaning: Försäljning och Shipments

Utdata krav

Lösning