In this advanced challenge, you will apply your skills in spotting and correcting both **syntax** and **indentation errors** within a single, longer Python script. Debugging code with multiple issues of this kind is a common real-world scenario and requires careful attention to detail, as fixing one error can sometimes reveal others. Your goal is to produce a script that runs successfully without any errors.


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

class TestTask(unittest.TestCase):
    def test_greet_output(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.greet("Alice")
        output = normalize_text(f.getvalue())
        expected = normalize_text("Hello, Alice")
        _dynamic_test(
            self,
            expected in output,
            "greet prints correct greeting for Alice",
            f"Expected output: '{expected}' not found in: '{output}'",
        )

    def test_add_numbers_output_and_return(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            result = user_code.add_numbers(5, 7)
        output = normalize_text(f.getvalue())
        expected = normalize_text("The sum is: 12")
        _dynamic_test(
            self,
            expected in output and result == 12,
            "add_numbers prints and returns correct sum for (5, 7)",
            f"Expected output: '{expected}' and return value 12, got output '{output}' and return {result}",
        )

    def test_even_odd_loop_output(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            for i in range(3):
                if i % 2 == 0:
                    print("Even number:", i)
                else:
                    print("Odd number:", i)
        expected_lines = [
            normalize_text("Even number: 0"),
            normalize_text("Odd number: 1"),
            normalize_text("Even number: 2"),
        ]
        actual_lines = [normalize_text(line) for line in f.getvalue().splitlines() if line.strip()]
        for expected in expected_lines:
            _dynamic_test(
                self,
                expected in actual_lines,
                f"Loop prints correct output: {expected}",
                f"Expected output: '{expected}' not found in: {actual_lines}",
            )

    def test_script_runs_without_error(self):
        import user_code
        try:
            importlib.reload(user_code)
            _dynamic_test(
                self,
                True,
                "Script runs without error",
                "Script runs without error"
            )
        except Exception as e:
            _dynamic_test(
                self,
                False,
                "",
                f"Script raised exception: {e}"
            )

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: Mixed Syntax and Indentation

Lösung