In this challenge, you will refactor a piece of code to use more Pythonic constructs. Your goal is to rewrite the provided code to make use of **list comprehensions** and **built-in functions**, replacing manual loops and unnecessary temporary variables. This exercise will help you practice writing code that is concise, readable, and takes full advantage of Python's strengths.


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_even_squares_output(self):
        code = """
def get_even_squares(numbers):
    return [n ** 2 for n in numbers if n % 2 == 0]

nums = [1, 2, 3, 4, 5, 6]
print(get_even_squares(nums))
"""
        ns = {}
        f = io.StringIO()
        with redirect_stdout(f):
            exec(code, ns)
        output = normalize_text(f.getvalue())
        expected = normalize_text("[4, 16, 36]")
        _dynamic_test(
            self,
            expected in output,
            f"Output includes line: {expected}",
            f"Expected output: '{expected}' not found in: '{output}'",
        )

    def test_function_return_value(self):
        import user_code
        importlib.reload(user_code)
        func = getattr(user_code, 'get_even_squares', None)
        _dynamic_test(
            self,
            callable(func),
            "Function get_even_squares exists and is callable",
            "Function get_even_squares is not defined correctly",
        )
        result = func([0, 1, 2, 3, 4, 5])
        expected = [0, 4, 16]
        _dynamic_test(
            self,
            isinstance(result, list) and result == expected,
            "Function returns correct even squares for [0, 1, 2, 3, 4, 5]",
            f"Expected {expected}, got {result}",
        )
        result2 = func([])
        expected2 = []
        _dynamic_test(
            self,
            isinstance(result2, list) and result2 == expected2,
            "Function returns empty list for empty input",
            f"Expected {expected2}, got {result2}",
        )
        result3 = func([1, 3, 5, 7])
        expected3 = []
        _dynamic_test(
            self,
            isinstance(result3, list) and result3 == expected3,
            "Function returns empty list for odd-only input",
            f"Expected {expected3}, got {result3}",
        )
        result4 = func([-2, -1, 0, 1, 2])
        expected4 = [4, 0, 4]
        _dynamic_test(
            self,
            isinstance(result4, list) and result4 == expected4,
            "Function returns correct even squares for negatives and zero",
            f"Expected {expected4}, got {result4}",
        )
    
    def test_no_side_effects(self):
        import user_code
        importlib.reload(user_code)
        nums = [2, 4, 6]
        nums_copy = nums[:]
        func = getattr(user_code, 'get_even_squares', None)
        func(nums)
        _dynamic_test(
            self,
            nums == nums_copy,
            "Input list is not modified by get_even_squares",
            f"Input list was modified: expected {nums_copy}, got {nums}",
        )

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: Refactor to Pythonic Style

Løsning