In Python, **mutable default arguments** can lead to subtle bugs that are often hard to spot. When you use a mutable object such as a `list` or `dict` as a default value for a function parameter, Python only creates that object once—at the time the function is defined, not each time the function is called. This can cause the function to share the same object across multiple calls, resulting in unexpected behavior.

Your task is to examine some functions that use **mutable default arguments** and refactor them so that each call to the function gets a new object, preventing unintended side effects.


import unittest
import user_code
import ast
import re   
import unittest
import importlib
import io
from contextlib import redirect_stdout

class TestTask(unittest.TestCase):
    def test_append_item_independent_lists(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.append_item(100)
            user_code.append_item(200)
        output = normalize_text(f.getvalue())
        cond1 = normalize_text("Current items: [100]") in output
        cond2 = normalize_text("Current items: [200]") in output
        _dynamic_test(
            self,
            cond1 and cond2,
            "Each call to append_item creates a new list when not provided.",
            f"Expected separate lists for each call. Got output: {output}",
        )

    def test_append_item_custom_list(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        items = [5, 6]
        with redirect_stdout(f):
            user_code.append_item(7, items)
        output = normalize_text(f.getvalue())
        cond = normalize_text("Current items: [5, 6, 7]") in output
        _dynamic_test(
            self,
            cond and items == [5, 6, 7],
            "append_item correctly appends to provided list.",
            f"Expected items to be [5, 6, 7]. Output: {output}, items: {items}",
        )

    def test_add_key_value_independent_dicts(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.add_key_value('x', 1)
            user_code.add_key_value('y', 2)
        output = normalize_text(f.getvalue())
        cond1 = normalize_text("Current mapping: {'x': 1}") in output
        cond2 = normalize_text("Current mapping: {'y': 2}") in output
        _dynamic_test(
            self,
            cond1 and cond2,
            "Each call to add_key_value creates a new dict when not provided.",
            f"Expected separate dicts for each call. Got output: {output}",
        )

    def test_add_key_value_custom_dict(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        mapping = {'a': 5}
        with redirect_stdout(f):
            user_code.add_key_value('b', 10, mapping)
        output = normalize_text(f.getvalue())
        cond = normalize_text("Current mapping: {'a': 5, 'b': 10}") in output
        _dynamic_test(
            self,
            cond and mapping == {'a': 5, 'b': 10},
            "add_key_value correctly adds to provided dict.",
            f"Expected mapping to be {{'a': 5, 'b': 10}}. Output: {output}, mapping: {mapping}",
        )

    def test_no_mutable_default_args(self):
        # Checks that the default values are None, not [] or {}
        import user_code
        import inspect
        sig1 = inspect.signature(user_code.append_item)
        sig2 = inspect.signature(user_code.add_key_value)
        arg1 = sig1.parameters['items'].default
        arg2 = sig2.parameters['mapping'].default
        _dynamic_test(
            self,
            arg1 is None and arg2 is None,
            "No mutable default arguments used.",
            f"Expected default arguments to be None, got {arg1} and {arg2}",
        )

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()

def change_var(code: str, var_name: str, value: str) -> str:
    tree = ast.parse(code)
    lines = code.splitlines()
    for i, node in enumerate(tree.body):
        if isinstance(node, ast.Assign):
            for target in node.targets:
                if isinstance(target, ast.Name) and target.id == var_name:
                    start_line = node.lineno - 1
                    line = lines[start_line]
                    indent = ' ' * (len(line) - len(line.lstrip()))
                    lines[start_line] = f"{indent}{var_name} = {value}"
                    next_line = len(lines)
                    for next_node in tree.body[i+1:]:
                        if hasattr(next_node, 'lineno'):
                            next_line = next_node.lineno - 1
                            break
                    if next_line > start_line + 1:
                        lines[start_line+1:next_line] = []
                    
                    return '\\n'.join(lines)
    return code

if __name__ == "__main__":
    unittest.main()


test_main.py

A practical course designed to help learners identify, understand, and fix frequent mistakes made by Python programmers. Through real-world examples and hands-on tasks, students will develop the skills to debug, refactor, and write more robust Python code.

Explore the most frequent syntax and indentation mistakes in Python, understand their causes, and learn strategies to avoid them.

Identify and resolve common mistakes related to variable naming, assignment, and scope in Python.

Uncover frequent logical mistakes, including off-by-one errors, improper comparisons, and boolean logic mishaps.

Investigate mistakes related to mutable default arguments, object references, and unintended side effects in Python functions.

Challenge: Default Argument Debugger

解答