In this challenge, you will practice spotting and correcting **common Python syntax errors**. Syntax errors prevent your code from running and are often caused by missing punctuation, incorrect indentation, or using the wrong keywords. You will be given several short code snippets, each containing a different syntax error. Your task is to fix each snippet so that it runs successfully.


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_print_greeting_output(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.print_greeting()
        output = normalize_text(f.getvalue())
        expected = normalize_text("Hello, Python learner!")
        _dynamic_test(
            self,
            expected in output,
            "print_greeting prints the correct greeting message",
            f"Expected output: '{expected}' not found in: '{output}'",
        )

    def test_calculate_sum(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.calculate_sum(3, 5)
        _dynamic_test(
            self,
            result == 8,
            "calculate_sum returns correct sum for (3, 5)",
            f"Expected 8, got {result}",
        )

    def test_is_even_true(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.is_even(4)
        _dynamic_test(
            self,
            result is True,
            "is_even returns True for even number (4)",
            f"Expected True for input 4, got {result}",
        )

    def test_is_even_false(self):
        import user_code
        importlib.reload(user_code)
        result = user_code.is_even(7)
        _dynamic_test(
            self,
            result is False,
            "is_even returns False for odd number (7)",
            f"Expected False for input 7, 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

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: Fixing Syntax Errors

Oplossing

Awesome!

Challenge: Fixing Syntax Errors

Oplossing