In this challenge, you will practice improving code readability by refactoring a poorly written Python function. Apply the **clean code principles** you have learned, such as using **meaningful names**, organizing code logically, and making your code easy to follow. Focus on making the function **clear** and **maintainable** for anyone who might read or modify it in the future.


import unittest
import user_code
import ast
import re   
import unittest
import user_code
import importlib

class TestTask(unittest.TestCase):
    def test_return_for_sample_input(self):
        importlib.reload(user_code)
        if hasattr(user_code, 'calculate_even_odd_difference'):
            result = user_code.calculate_even_odd_difference([1, 2, 3, 4, 5])
        else:
            result = user_code.f([1, 2, 3, 4, 5])
        _dynamic_test(
            self,
            result == -3,
            "Function returns correct value for [1, 2, 3, 4, 5]",
            f"Expected return value -3, got {result}",
        )

    def test_return_for_even_numbers(self):
        importlib.reload(user_code)
        if hasattr(user_code, 'calculate_even_odd_difference'):
            result = user_code.calculate_even_odd_difference([2, 4, 6, 8])
        else:
            result = user_code.f([2, 4, 6, 8])
        _dynamic_test(
            self,
            result == 20,
            "Function returns correct value for [2, 4, 6, 8]",
            f"Expected return value 20, got {result}",
        )

    def test_return_for_odd_numbers(self):
        importlib.reload(user_code)
        if hasattr(user_code, 'calculate_even_odd_difference'):
            result = user_code.calculate_even_odd_difference([1, 3, 5, 7])
        else:
            result = user_code.f([1, 3, 5, 7])
        _dynamic_test(
            self,
            result == -16,
            "Function returns correct value for [1, 3, 5, 7]",
            f"Expected return value -16, got {result}",
        )

    def test_return_for_empty_list(self):
        importlib.reload(user_code)
        if hasattr(user_code, 'calculate_even_odd_difference'):
            result = user_code.calculate_even_odd_difference([])
        else:
            result = user_code.f([])
        _dynamic_test(
            self,
            result == 0,
            "Function returns correct value for []",
            f"Expected return value 0, got {result}",
        )

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: Improve Readability

Ratkaisu

Awesome!

Challenge: Improve Readability

Ratkaisu