Are you ready to apply your new knowledge of **lists** and **list methods** in a practical setting? 

This challenge will engage you in managing a grocery store's **deli department items**, requiring you to utilize nested lists, list methods, and conditional logic.

import unittest
import io
import re
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 strip_comments_from_source(path):
    try:
        with open(path, 'r') as file:
            source = file.read()
        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 TestDeliInventory(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 run_code(self):
        with open('user_code.py', 'r') as f:
            code = f.read()

        f = io.StringIO()
        with redirect_stdout(f):
            exec(code, {})
        return self.normalize_text(f.getvalue())

    def test_initial_print_present(self):
        output = self.run_code()
        _dynamic_test(
            self,
            "initial deli list:" in output,
            "Initial print statement is present",
            "Expected 'Initial Deli List:' in output"
        )

    def test_updated_print_present(self):
        output = self.run_code()
        _dynamic_test(
            self,
            "updated deli list:" in output,
            "Updated print statement is present",
            "Expected 'Updated Deli List:' in output"
        )

    def test_ham_quantity_updated(self):
        import importlib
        import user_code
        importlib.reload(user_code)
        _dynamic_test(
            self,
            user_code.meat[2] == 100,
            "Ham quantity updated to 100",
            f"Expected Ham quantity to be 100, got {user_code.meat[2]}"
        )

    def test_seasonal_meat_added(self):
        import importlib
        import user_code
        importlib.reload(user_code)
        found = any(item[0] == "Turkey" for item in user_code.deli_dept)
        _dynamic_test(
            self,
            found,
            "Turkey added to deli_dept",
            "Turkey not found in deli_dept"
        )

    def test_condiment_removed(self):
        import importlib
        import user_code
        importlib.reload(user_code)
        found = any(item[0] == "Mustard" for item in user_code.deli_dept)
        _dynamic_test(
            self,
            not found,
            "Condiment 'Mustard' removed from deli_dept",
            "'Mustard' still found in deli_dept"
        )

    def test_list_sorted_by_first_element(self):
        import importlib
        import user_code
        importlib.reload(user_code)
        names = [item[0] for item in user_code.deli_dept]
        _dynamic_test(
            self,
            names == sorted(names),
            "deli_dept is sorted alphabetically by item type",
            f"Expected sorted deli_dept, got order: {names}"
        )

    def test_list_structure_preserved(self):
        import importlib
        import user_code
        importlib.reload(user_code)
        _dynamic_test(
            self,
            all(isinstance(item, list) and len(item) == 4 for item in user_code.deli_dept),
            "Each item in deli_dept is a 4-element list",
            "Not all items in deli_dept are 4-element lists"
        )


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.

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!

How can you access the third element in this list?

How would you change "green" to "yellow"?

Challenge: List Management

Output Requirements

Oplossing

Awesome!

Challenge: List Management

Output Requirements

Oplossing