In Python, **off-by-one errors** and incorrect ranges in loops and slices are common causes of subtle bugs. Such mistakes can result in missing the first or last element, processing too many items, or skipping important data. These issues often arise when using `range()` in loops, or when slicing lists, because Python uses zero-based indexing and the end index is exclusive. Paying careful attention to the start and end points of ranges and slices is essential for correct program logic.


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_all_numbers_printed(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        expected_numbers = [10, 20, 30, 40, 50, 60]
        for n in expected_numbers:
            expected_line = normalize_text(f"Number: {n}")
            _dynamic_test(
                self,
                expected_line in output,
                f"Output includes line: {expected_line}",
                f"Expected output: '{expected_line}' not found in: '{output}'",
            )
        # Check that each number appears exactly once
        for n in expected_numbers:
            count = output.count(normalize_text(f"Number: {n}"))
            _dynamic_test(
                self,
                count == 1,
                f"Number {n} printed exactly once",
                f"Number {n} printed {count} times; expected once.",
            )

    def test_middle_numbers_slice(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        expected_middle = [20, 30, 40, 50]
        expected_line = normalize_text(f"Middle numbers: {expected_middle}")
        _dynamic_test(
            self,
            expected_line in output,
            f"Middle numbers output is correct: {expected_line}",
            f"Expected output: '{expected_line}' not found in: '{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: Loop Range Repair

Solución

Awesome!

Challenge: Loop Range Repair

Solución