Python3 exec()函数调用不符合预期：code1正常code2报错求解释

Hey there! Let's dig into why your exec() call isn't behaving as expected inside a function, and why code1.py works while code2.py throws errors. This boils down to how Python handles scoping with dynamic execution—a key intentional difference between Python 2 and 3.

The Core Issue: Scoping Isolation in Functions #

In Python 3, when you use exec() inside a function, it doesn’t automatically modify the function’s local scope by default. Here’s the breakdown:
Python compiles function definitions statically. When it parses your function, it builds a fixed list of all local variables it expects to exist based on explicit assignments in the code. Any variables created dynamically via exec() aren’t added to this pre-compiled list, so when you try to access them later, Python throws a NameError—it acts like the variable was never defined at all.

Example of code1.py (Working as Expected) #

Chances are code1.py uses exec() in the global scope, where Python lets dynamic code modify the namespace directly:

# code1.py (runs without issues)
exec("greeting = 'Hello from exec!'")
print(greeting)  # Output: Hello from exec!

Global scope doesn’t enforce the same static variable checking as function local scopes, so exec() can freely add or modify variables here.

Example of code2.py (Throws Errors) #

code2.py is likely using exec() inside a function without handling the scope properly:

# code2.py (throws NameError)
def my_function():
    exec("counter = 10")
    print(counter)  # Error: name 'counter' is not defined

my_function()

Even though exec() runs and creates counter, Python’s static scoping rules mean counter isn’t recognized as a valid local variable in the function.

Fixing the Issue #

To make exec() work reliably inside functions, you need to explicitly manage the scope it uses:

1. Use a Custom Dictionary for Local Variables #

Pass a dictionary as the third argument to exec()—this dict will hold any variables created by the dynamic code, keeping them isolated from the function’s actual local scope:

def my_function():
    dynamic_vars = {}
    # Pass global scope (optional) and our custom local scope
    exec("counter = 10", globals(), dynamic_vars)
    print(dynamic_vars['counter'])  # Output: 10

This is the recommended approach because it avoids unexpected side effects and makes your code’s behavior predictable.

2. (Not Recommended) Force Modification of Local Scope #

If you absolutely need to inject variables into the function’s local scope, you can use locals()—but note that in Python 3, locals() returns a copy of the local scope. You’ll need to manually update the actual scope (this is fragile and not best practice):

def my_function():
    exec("counter = 10", globals(), locals())
    # Manually sync the local scope with the copy from locals()
    locals().update(locals())
    print(counter)  # Might work, but behavior can vary across Python versions

Why This Design Choice? #

Python 3 changed this behavior from Python 2 to improve code safety and predictability. Dynamic code executed via exec() can’t accidentally overwrite or create local variables in a function, which prevents hard-to-debug bugs caused by unexpected scope modifications.

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