Summary  
This chapter explains how mutable lists passed into functions can be modified in place and shows how to create a shallow copy with the copy() method to avoid unintended changes to the original list.

General domain of usage  
Data processing

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

Use index-based iteration to ensure the list is modified correctly: `for index in range(len(prices)):` modifies elements directly, unlike `for price in prices:`.

Note

Gain a solid foundation in Python for data analysis. Learn to work with variables, data types, strings, conditional statements, loops, core data structures, and functions using examples relevant to analytical tasks.

List Behavior in Functions

Output Requirements

Lösung