Let's explore **working with lists inside functions**. While it's similar to working with numbers, there are a few important details to be aware of.

Lists are **mutable**, meaning that any changes made to a list **inside a function** will also affect the **original list** outside the function if passed directly.

To prevent this, you can use the `copy()` method with any mutable data type. By doing so, you create a **shallow copy** of the list, allowing you to **modify a duplicate** instead of the original. This ensures that **changes made within the function don't impact the original list**.

def add_strawberry(original_list):
    list_copy = original_list.copy()  # Create a copy of the original list
    list_copy.append("Strawberry")  # Modify the copied list
    return list_copy

# Original list
fruits = ["Apple", "Banana", "Cherry"]

# Call the function
new_fruits = add_strawberry(fruits)

# Check the results
print("Original list:", fruits)   # ['Apple', 'Banana', 'Cherry']
print("Modified list:", new_fruits)  # ['Apple', 'Banana', 'Cherry', 'Strawberry']


In this example, the original `fruits` list remains unchanged because `copy()` was used. Without `copy()`, modifying the list inside the function would have changed the original `fruits` list as well.

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 TestApplyDiscount(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_function_exists(self):
        importlib.reload(user_code)
        _dynamic_test(
            self,
            hasattr(user_code, 'apply_discount'),
            "Function 'apply_discount' is defined",
            "Function 'apply_discount' is not defined"
        )

    def test_discount_applied_correctly(self):
        importlib.reload(user_code)
        test_input = [1.50, 2.50, 3.00, 0.99, 2.30]
        expected = [1.50, 2.25, 2.70, 0.99, 2.07]
        result = user_code.apply_discount(test_input)
        _dynamic_test(
            self,
            all(round(a, 2) == round(b, 2) for a, b in zip(result, expected)),
            "apply_discount returns correct discounted list",
            f"Expected {expected}, got {result}"
        )

    def test_original_list_unchanged(self):
        importlib.reload(user_code)
        test_input = [2.10, 2.90, 1.00]
        input_copy = test_input.copy()
        user_code.apply_discount(test_input)
        _dynamic_test(
            self,
            test_input == input_copy,
            "Original list remains unchanged after apply_discount",
            f"Expected original list to remain {input_copy}, but got {test_input}"
        )

    def test_output_format(self):
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = self.normalize_text(f.getvalue())
        expected_start = self.normalize_text("Updated product prices:")
        _dynamic_test(
            self,
            expected_start in output,
            "Output contains 'Updated product prices:'",
            "Expected output to contain 'Updated product prices:'"
        )


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!

List Behavior in Functions

Output Requirements

解答