In this challenge, you'll **manage the daily stock levels** of essential grocery store products over a week. By utilizing the `range()` function in conjunction with the `len()` function, you'll simulate sales impacts on inventory.


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

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 normalize_text(text):
    text = text.lower()
    text = re.sub(r"\\s{2,}", " ", text)
    text = re.sub(r"\\s*([,:?])\\s*", r"\\1 ", text)
    return text.strip()

class TestStockProcessing(unittest.TestCase):

    def capture_output(self):
        import user_code
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        return normalize_text(f.getvalue())

    def test_after_sales_printed_correctly(self):
        output = self.capture_output()
        products = [["Apples", 150, 30], ["Bananas", 200, 45], ["Oranges", 100, 20], ["Mangoes", 120, 10]]
        all_ok = True
        missing = []
        for name, initial, sold in products:
            expected = normalize_text(f"{name} stock after sales: {initial - sold}")
            if expected not in output:
                all_ok = False
                missing.append(expected)
        _dynamic_test(
            self,
            all_ok,
            "Printed stock after sales matches expected for all products",
            f"Missing or incorrect after-sales stock lines: {missing}"
        )

    def test_after_shipments_printed_correctly(self):
        output = self.capture_output()
        products = [["Apples", 150, 30, 50], ["Bananas", 200, 45, 70], ["Oranges", 100, 20, 30], ["Mangoes", 120, 10, 40]]
        all_ok = True
        missing = []
        for name, initial, sold, received in products:
            mid = initial - sold
            expected = normalize_text(f"{name} stock after shipment: {mid + received}")
            if expected not in output:
                all_ok = False
                missing.append(expected)
        _dynamic_test(
            self,
            all_ok,
            "Printed stock after shipments matches expected for all products",
            f"Missing or incorrect after-shipment stock lines: {missing}"
        )

    def test_final_stock_printed_correctly(self):
        output = self.capture_output()
        products = [["Apples", 150, 30, 50], ["Bananas", 200, 45, 70], ["Oranges", 100, 20, 30], ["Mangoes", 120, 10, 40]]
        all_ok = True
        missing = []
        for name, initial, sold, received in products:
            final = initial - sold + received
            expected = normalize_text(f"Final stock for {name}: {final}")
            if expected not in output:
                all_ok = False
                missing.append(expected)
        _dynamic_test(
            self,
            all_ok,
            "Printed final stock matches expected for all products",
            f"Missing or incorrect final stock lines: {missing}"
        )

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

test_main.py

Python is a high-level, interpreted, general-purpose programming
language. Distinguished from languages such as HTML, CSS, and JavaScript, which are mainly
utilized in web development, Python boasts versatility across multiple domains, including
software development, data science, and back-end development. This course will guide you
through Python's fundamental concepts, equipping you with the skills to create your own
functions by the conclusion of the program.

Python

In this section, you will explore the fundamentals of Python, get acquainted
with your workspace, perform simple math operations, and display your findings.

In this section, you'll discover how to save items such as numbers and text
in computer memory and retrieve them by name. Additionally, you'll gain an introduction to text
manipulation in Python.

In this section, you'll explore the boolean data type and learn how it is used
to develop programs that react to certain conditions.

In this section, you will continue learning about data types and discover
how to organize various attributes in a single variable using lists, tuples, and dictionaries.

In this section, you'll learn how to create loops in Python — an essential skill
for iterating through lists, tuples, and dictionaries.

To conclude this introductory course, you will explore some built-in
functions and then begin to develop your own!

Challenge: Sales and Shipments

Output Requirements

Requirements checklist

解答