Got it, let's break down how to get your main() function's local variables showing up in the Variable Explorer—since by default most tools only surface global variables. Here are a few practical approaches depending on your workflow:

1. Store Local Variables in a Container (Cleanest Approach) #

Instead of scattering variables in main()'s local scope, wrap them up in a dictionary or class instance, then return that container to the global scope. This keeps your global namespace clean while letting you inspect all main() variables in one place.

Example code:

def func1():
    return 42

def func2():
    return "hello world"

def main():
    # Use a dictionary to hold all local variables
    main_data = {}
    main_data["calc_result"] = func1()
    main_data["text_output"] = func2()
    # Add any other variables you want to track
    main_data["counter"] = 100
    return main_data

# Assign the container to a global variable
main_vars = main()

Now your Variable Explorer will show main_vars—just expand it to see all the variables you stored from main().

2. Use Debug Mode to Inspect Local Scope #

Most IDEs (like Spyder, PyCharm, VS Code) let you inspect local variables when debugging. Here's how it works:

• Set a breakpoint inside your main() function (click the gutter next to the line number in your IDE).
• Run your code in debug mode. When the program pauses at the breakpoint, the Variable Explorer will automatically switch to show the current local scope of main().
• You can even switch between different stack frames (like other functions called by main()) to inspect their variables too.

This is great for troubleshooting because you don't have to modify your code at all.

3. Temporarily Promote Variables to Global (Not Recommended) #

If you need a quick-and-dirty fix, you can declare variables as global inside main() or manually add them to the global namespace. Note: This clutters the global scope and can lead to bugs, so only use this for quick checks.

Example with global keyword:

def main():
    global calc_result, text_output
    calc_result = func1()
    text_output = func2()

Or manually add to the global dictionary:

def main():
    temp_var = func1()
    globals()["temp_var"] = temp_var  # Adds temp_var to global scope

4. Jupyter Notebook Specific Trick #

If you're working in Jupyter, you can have main() return its local variables directly, then assign the result to a global variable:

def main():
    a = func1()
    b = func2()
    return locals()  # Returns all local variables as a dictionary

main_locals = main()

You can also use the %debug magic command after running main()—it drops you into a debugger where you can type locals() to see all variables from main()'s scope.

内容的提问来源于stack exchange，提问作者Py_Student