In this challenge, you will apply the **extract function** technique to improve a Python script. You are given a long function that performs several tasks in sequence, making it harder to read and maintain. Your goal is to refactor this function by breaking it into at least two smaller, well-named helper functions. This approach will help you organize the logic, make each part easier to understand, and improve the overall code quality.


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_output_for_example(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            print(user_code.process_data([1, -2, 3, 4, -5]))
        output = normalize_text(f.getvalue())
        expected = normalize_text("Sum of squares (non-negative numbers): 26")
        _dynamic_test(
            self,
            expected in output,
            "Correct output for [1, -2, 3, 4, -5]",
            f"Expected '{expected}', got '{output}'",
        )

    def test_output_for_all_negative(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            print(user_code.process_data([-1, -2, -3]))
        output = normalize_text(f.getvalue())
        expected = normalize_text("Sum of squares (non-negative numbers): 0")
        _dynamic_test(
            self,
            expected in output,
            "Correct output for all negative input",
            f"Expected '{expected}', got '{output}'",
        )

    def test_output_for_empty_list(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            print(user_code.process_data([]))
        output = normalize_text(f.getvalue())
        expected = normalize_text("Sum of squares (non-negative numbers): 0")
        _dynamic_test(
            self,
            expected in output,
            "Correct output for empty input list",
            f"Expected '{expected}', got '{output}'",
        )

    def test_helpers_exist(self):
        import user_code
        importlib.reload(user_code)
        has_remove_neg = hasattr(user_code, 'remove_negatives')
        has_sum_sq = hasattr(user_code, 'sum_of_squares')
        _dynamic_test(
            self,
            has_remove_neg and has_sum_sq,
            "Both helper functions 'remove_negatives' and 'sum_of_squares' exist",
            "Missing one or both required helper functions",
        )

    def test_helpers_behavior(self):
        import user_code
        importlib.reload(user_code)
        if hasattr(user_code, 'remove_negatives'):
            res = user_code.remove_negatives([1, -2, 3, -4, 0])
            _dynamic_test(
                self,
                res == [1, 3, 0],
                "remove_negatives returns correct result",
                f"Expected [1, 3, 0], got {res}",
            )
        if hasattr(user_code, 'sum_of_squares'):
            res = user_code.sum_of_squares([2, 3])
            _dynamic_test(
                self,
                res == 13,
                "sum_of_squares returns correct result",
                f"Expected 13, got {res}",
            )

    def test_process_data_uses_helpers(self):
        # This test checks if process_data calls the helper functions by modifying them
        code = ''
        with open('user_code.py', 'r') as f:
            code = f.read()
        code = code.replace('def remove_negatives(numbers):', 'def remove_negatives(numbers):\\n    return [42]')
        code = code.replace('def sum_of_squares(numbers):', 'def sum_of_squares(numbers):\\n    return 99')
        ns = {}
        exec(code, ns)
        output = ns['process_data']([1, 2, 3])
        _dynamic_test(
            self,
            '99' in str(output),
            "process_data uses helper functions' results",
            f"process_data does not use helper functions correctly; got output: {output}",
        )

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: Extract Functions

Oplossing

Awesome!

Challenge: Extract Functions

Oplossing