In this challenge, you will **sharpen your ability to spot and correct common logical errors** in Python code, especially those involving **assignment versus comparison** and the use of **boolean logic**. These types of mistakes can cause code to behave unexpectedly, even when it runs without syntax errors. Your task is to read the provided code snippets, **identify the logical flaws**, and make the necessary corrections so the code executes as intended.


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_passed_output(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.check_pass(85)
        output = normalize_text(f.getvalue())
        expected = normalize_text("Passed")
        _dynamic_test(
            self,
            expected in output,
            "Correctly prints 'Passed' for score >= 70",
            f"Expected output 'Passed' for score 85, got: {output}",
        )

    def test_failed_output(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.check_pass(65)
        output = normalize_text(f.getvalue())
        expected = normalize_text("Failed")
        _dynamic_test(
            self,
            expected in output,
            "Correctly prints 'Failed' for score < 70",
            f"Expected output 'Failed' for score 65, got: {output}",
        )

    def test_exact_70(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.check_pass(70)
        output = normalize_text(f.getvalue())
        expected = normalize_text("Passed")
        _dynamic_test(
            self,
            expected in output,
            "Correctly prints 'Passed' for score 70",
            f"Expected output 'Passed' for score 70, got: {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

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: Logic Fixer

解答