We still have a few functions from the previous chapter to cover, so let's get some practice with them. 

Recall the `zip()` function, which is particularly useful when working with **multiple related lists**. This function allows you to manage different properties of items simultaneously, such as sorting products **while maintaining their associated attributes**.

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.rstrip()
            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 TestSortedProductOutput(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_combined_list_correct(self):
        importlib.reload(user_code)
        expected = [
            ("Banana", 1.20, 50),
            ("Apple", 0.50, 100),
            ("Mango", 2.50, 25),
            ("Cherry", 1.75, 40)
        ]
        _dynamic_test(
            self,
            user_code.combined_list == expected,
            "combined_list is correctly zipped from products, prices, and quantities_sold",
            f"Expected combined_list = {expected}, got {user_code.combined_list}"
        )

    def test_sorted_products_correct(self):
        importlib.reload(user_code)
        expected = [
            ("Apple", 0.50, 100),
            ("Banana", 1.20, 50),
            ("Cherry", 1.75, 40),
            ("Mango", 2.50, 25)
        ]
        _dynamic_test(
            self,
            user_code.sorted_products == expected,
            "sorted_products is correctly sorted by product name",
            f"Expected sorted_products = {expected}, got {user_code.sorted_products}"
        )

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

        expected_lines = [
            "Product: Apple, Price: 0.5, Quantity Sold: 100",
            "Product: Banana, Price: 1.2, Quantity Sold: 50",
            "Product: Cherry, Price: 1.75, Quantity Sold: 40",
            "Product: Mango, Price: 2.5, Quantity Sold: 25"
        ]

        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_zip_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            'zip(' in source,
            "'zip()' is used to combine the lists",
            "Expected use of 'zip()' not found in code"
        )

    def test_sorted_used(self):
        source = strip_comments_from_source(user_code)
        _dynamic_test(
            self,
            'sorted(' in source,
            "'sorted()' is used to sort the combined list",
            "Expected use of 'sorted()' not found in code"
        )


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!

Challenge: Zip and Sort Functions

Code Instructions

Output Requirements

解答