In this challenge, you will apply your knowledge of **Pythonic best practices** to identify and eliminate **anti-patterns** in a provided script. **Anti-patterns** are common coding habits that can harm readability, maintainability, or performance. Your goal is to refactor the code so that it adheres to the principles of **clean, idiomatic Python** you have learned so far.


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_to_list_no_mutable_default(self):
        import user_code
        importlib.reload(user_code)
        # Call twice to check for shared list
        first = user_code.append_to_list(1)
        second = user_code.append_to_list(2)
        _dynamic_test(
            self,
            first == [1] and second == [2],
            "append_to_list does not share mutable default",
            f"Expected [1] and [2], got {first} and {second}",
        )

    def test_append_to_list_with_custom_list(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.append_to_list(5, [10, 20])
        _dynamic_test(
            self,
            result == [10, 20, 5],
            "append_to_list appends to provided list",
            f"Expected [10, 20, 5], got {result}",
        )

    def test_process_numbers_pythonic(self):
        import user_code
        importlib.reload(user_code)
        # function should be renamed and use comprehension
        func = getattr(user_code, 'double_evens', None)
        _dynamic_test(
            self,
            callable(func),
            "Function double_evens exists",
            "Function double_evens not found or not callable",
        )
        result = func([1, 2, 3, 4])
        _dynamic_test(
            self,
            result == [1, 4, 3, 8],
            "double_evens returns correct output",
            f"Expected [1, 4, 3, 8], got {result}",
        )

    def test_max_of_two(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'max_of_two', None)
        _dynamic_test(
            self,
            callable(func),
            "Function max_of_two exists",
            "Function max_of_two not found or not callable",
        )
        result = func(10, 20)
        _dynamic_test(
            self,
            result == 20,
            "max_of_two returns correct maximum",
            f"Expected 20, got {result}",
        )
        result2 = func(30, 5)
        _dynamic_test(
            self,
            result2 == 30,
            "max_of_two returns correct maximum",
            f"Expected 30, got {result2}",
        )

    def test_unused_function_removed(self):
        import user_code
        importlib.reload(user_code)
        unused = getattr(user_code, 'unused_function', None)
        _dynamic_test(
            self,
            unused is None,
            "unused_function is removed",
            "unused_function should be removed from the 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 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

Master the principles of writing clean, maintainable, and efficient Python code. Learn to identify code smells, apply refactoring techniques, and adopt best practices for code quality. Practice your skills with hands-on tasks designed for those familiar with basic Python syntax.

Explore the fundamental concepts of code quality, why it matters, and how to recognize poor code in Python.

Delve into practical refactoring methods to enhance Python code structure and eliminate code smells.

Adopt Pythonic conventions and idioms to write elegant, efficient, and maintainable code.

Learn strategies for maintaining code quality over time, including documentation, testing, and code reviews.

Challenge: Eliminate Anti-Patterns

Oplossing

Awesome!

Challenge: Eliminate Anti-Patterns

Oplossing