Let's put together everything you've learned in this section and apply it.

In this task, your objective is to calculate the **total revenue for each product** in a grocery store based on their prices and quantities sold. 

After calculating the revenues, you will **sort the products alphabetically** and **display the results** in a formatted output.

import unittest
import importlib
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 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 TestRevenueFunctions(unittest.TestCase):

    def test_calculate_revenue_return_values(self):
        import user_code
        importlib.reload(user_code)
        prices = [0.50, 1.20, 2.50, 2.00]
        quantities = [150, 200, 100, 50]
        result = user_code.calculate_revenue(prices, quantities)
        expected = [p * q for p, q in zip(prices, quantities)]
        condition = isinstance(result, list) and len(result) == len(expected) and all(r == e for r, e in zip(result, expected))
        _dynamic_test(
            self,
            condition,
            "calculate_revenue returns correct list of products of elements",
            f"Expected {expected}, got {result}"
        )

    def test_formatted_output_prints_four_lines(self):
        import user_code
        importlib.reload(user_code)
        data = [("Bread", 75.0), ("Apples", 240.0), ("Oranges", 250.0), ("Bananas", 100.0)]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.formatted_output(data)
        output = normalize_text(f.getvalue())
        lines = [l for l in output.split("\\n") if l]
        condition = len(lines) == 4 and all(re.match(r"[a-z]+ has total revenue of \\$\\d+(\\.\\d+)?", l) for l in lines)
        _dynamic_test(
            self,
            condition,
            "formatted_output prints four correctly formatted lines",
            f"Output lines incorrect or wrong count: {lines}"
        )

    def test_example_output_contains_expected_lines(self):
        import user_code
        importlib.reload(user_code)
        data = [("Bread", 75.0), ("Apples", 240.0), ("Oranges", 250.0), ("Bananas", 100.0)]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.formatted_output(data)
        output = normalize_text(f.getvalue())
        expected_lines = [
            "apples has total revenue of $240.0",
            "bananas has total revenue of $100.0",
            "bread has total revenue of $75.0",
            "oranges has total revenue of $250.0"
        ]
        all_present = all(e in output for e in expected_lines)
        _dynamic_test(
            self,
            all_present,
            "Output contains all expected example lines",
            f"Missing expected lines in output. Got: {output}"
        )

    def test_formatted_output_sorts_input(self):
        import user_code
        importlib.reload(user_code)
        # shuffle input
        data = [("Oranges", 250.0), ("Bread", 75.0), ("Bananas", 100.0), ("Apples", 240.0)]
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.formatted_output(data)
        output = normalize_text(f.getvalue()).split("\\n")
        filtered = [l for l in output if l]
        sorted_names = [l.split(" ")[0] for l in filtered]
        condition = sorted_names == sorted(sorted_names)
        _dynamic_test(
            self,
            condition,
            "formatted_output sorts input alphabetically by product name",
            f"Output order {sorted_names} is not alphabetical"
        )

    def test_calculate_revenue_does_not_modify_inputs(self):
        import user_code
        importlib.reload(user_code)
        prices = [0.50, 1.20, 2.50, 2.00]
        quantities = [150, 200, 100, 50]
        original_prices = prices.copy()
        original_quantities = quantities.copy()
        _ = user_code.calculate_revenue(prices, quantities)
        condition = prices == original_prices and quantities == original_quantities
        _dynamic_test(
            self,
            condition,
            "calculate_revenue does not modify input lists",
            f"Input lists were modified: prices {prices}, quantities {quantities}"
        )

    def test_formatted_output_returns_none(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.formatted_output([("A", 1.0)])
        condition = result is None
        _dynamic_test(
            self,
            condition,
            "formatted_output returns None",
            f"formatted_output returned {result} instead of None"
        )

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: Product Revenues Capstone

Output Requirements

Requirements checklist

解答