Variable scope issues can cause some of the most confusing bugs in Python programs. When you use the same variable name inside and outside a function, you might expect changes to affect the same variable, but Python treats variables differently depending on where and how they are assigned. If you accidentally create a local variable when you meant to update a global one, or if you try to use a variable before it is properly defined, your code may not work as intended. Being able to spot and fix these problems is an **essential skill** for any Python programmer.


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_increment_counter_global(self):
        import user_code
        importlib.reload(user_code)
        counter = getattr(user_code, 'counter', None)
        _dynamic_test(
            self,
            isinstance(counter, int) and counter == 1,
            "Counter was incremented globally to 1",
            f"Expected global counter to be 1, got {counter}",
        )

    def test_print_message_uses_outer(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            user_code.print_message()
        output = normalize_text(f.getvalue())
        expected = normalize_text(getattr(user_code, 'message', None))
        _dynamic_test(
            self,
            expected in output,
            f"print_message prints the outer message: {expected}",
            f"Expected outer message '{expected}' in output, got '{output}'",
        )

    def test_print_counter_output(self):
        import user_code
        importlib.reload(user_code)
        f = io.StringIO()
        with redirect_stdout(f):
            importlib.reload(user_code)
        output = normalize_text(f.getvalue())
        counter = getattr(user_code, 'counter', None)
        _dynamic_test(
            self,
            str(counter) in output,
            f"Output includes the correct counter value: {counter}",
            f"Expected to find '{counter}' in output, got: '{output}'",
        )

    def test_no_local_message_shadowing(self):
        import user_code
        importlib.reload(user_code)
        code = """
counter = 0
message = 'Test Message!'
def increment_counter():
    global counter
    counter += 1
def print_message():
    print(message)
increment_counter()
print(counter)
print_message()
"""
        ns = {}
        exec(code, ns)
        f = io.StringIO()
        with redirect_stdout(f):
            ns['print_message']()
        output = normalize_text(f.getvalue())
        expected = normalize_text(ns['message'])
        _dynamic_test(
            self,
            expected in output,
            f"No local shadowing: 'print_message' prints outer message {expected}",
            f"Expected outer message '{expected}' in output, 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: Scope Detective

Oplossing

Awesome!

Challenge: Scope Detective

Oplossing