This issue is somewhat discussed in the Python3 bug list. Ultimately, to get this behavior, you need to do:
def foo():
ldict = {}
exec("a = 3", globals(), ldict)
a = ldict['a']
print(a)
And if you check the Python3 documentation on exec, you'll see the following note:
The default locals act as described for function
locals()below: modifications to the default locals dictionary should not be attempted. Pass an explicit locals dictionary if you need to see effects of the code on locals after functionexec()returns.
That means that one-argument exec can't safely perform any operations that would bind local variables, including variable assignment, imports, function definitions, class definitions, etc. It can assign to globals if it uses a global declaration, but not locals.
Referring back to a specific message on the bug report, Georg Brandl says:
To modify the locals of a function on the fly is not possible without several consequences: normally, function locals are not stored in a dictionary, but an array, whose indices are determined at compile time from the known locales [sic]. This collides at least with new locals added by exec.
Then, regarding Python 2:
The old exec statement circumvented this, because the compiler knew that if an exec without globals/locals args occurred in a function, that namespace would be "unoptimized", i.e. not using the locals array. Since exec() is now a normal function, the compiler does not know what "exec" may be bound to, and therefore can not treat is specially.
Emphasis is mine.
So the gist of it is that Python3 can better optimize the use of local variables by not allowing this behavior by default.
And for the sake of completeness, this does work as expected in Python 2.X:
Python 2.6.2 (release26-maint, Apr 19 2009, 01:56:41)
[GCC 4.3.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> def f():
... a = 1
... exec "a=3"
... print a
...
>>> f()
3
This issue is somewhat discussed in the Python3 bug list. Ultimately, to get this behavior, you need to do:
def foo():
ldict = {}
exec("a = 3", globals(), ldict)
a = ldict['a']
print(a)
And if you check the Python3 documentation on exec, you'll see the following note:
The default locals act as described for function
locals()below: modifications to the default locals dictionary should not be attempted. Pass an explicit locals dictionary if you need to see effects of the code on locals after functionexec()returns.
That means that one-argument exec can't safely perform any operations that would bind local variables, including variable assignment, imports, function definitions, class definitions, etc. It can assign to globals if it uses a global declaration, but not locals.
Referring back to a specific message on the bug report, Georg Brandl says:
To modify the locals of a function on the fly is not possible without several consequences: normally, function locals are not stored in a dictionary, but an array, whose indices are determined at compile time from the known locales [sic]. This collides at least with new locals added by exec.
Then, regarding Python 2:
The old exec statement circumvented this, because the compiler knew that if an exec without globals/locals args occurred in a function, that namespace would be "unoptimized", i.e. not using the locals array. Since exec() is now a normal function, the compiler does not know what "exec" may be bound to, and therefore can not treat is specially.
Emphasis is mine.
So the gist of it is that Python3 can better optimize the use of local variables by not allowing this behavior by default.
And for the sake of completeness, this does work as expected in Python 2.X:
Python 2.6.2 (release26-maint, Apr 19 2009, 01:56:41)
[GCC 4.3.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> def f():
... a = 1
... exec "a=3"
... print a
...
>>> f()
3
The reason that you can't change local variables within a function using exec in that way, and why exec acts the way it does, can be summarized as following:
execis a function that shares its local scope with the scope of the most inner scope in which it's called.- Whenever you define a new object within a function's scope it'll be accessible in its local namespace, i.e. it will modify the
local()dictionary. When you define a new object inexecwhat it does is roughly equivalent to following:
from copy import copy
class exec_type:
def __init__(self, *args, **kwargs):
# default initializations
# ...
self.temp = copy(locals())
def __setitem__(self, key, value):
if var not in locals():
set_local(key, value)
self.temp[key] = value
temp is a temporary namespace that resets after each instantiation (each time you call the exec).
- Python starts looking up for the names from local namespace. It's known as LEGB manner. Python starts from Local namespce then looks into the Enclosing scopes, then Global and at the end it looks up the names within Buit-in namespace.
A more comprehensive example would be something like following:
g_var = 5
def test():
l_var = 10
print(locals())
exec("print(locals())")
exec("g_var = 222")
exec("l_var = 111")
exec("print(locals())")
exec("l_var = 111; print(locals())")
exec("print(locals())")
print(locals())
def inner():
exec("print(locals())")
exec("inner_var = 100")
exec("print(locals())")
exec("print([i for i in globals() if '__' not in i])")
print("Inner function: ")
inner()
print("-------" * 3)
return (g_var, l_var)
print(test())
exec("print(g_var)")
Output:
{'l_var': 10}
{'l_var': 10}
locals are the same.
{'l_var': 10, 'g_var': 222}
after adding g_var and changing the l_var it only adds g_var and left the l_var unchanged.
{'l_var': 111, 'g_var': 222}
l_var is changed because we are changing and printing the locals in one instantiation ( one call to exec).
{'l_var': 10, 'g_var': 222}
{'l_var': 10, 'g_var': 222}
In both function's locals and exec's local l_var is unchanged and g_var is added.
Inner function:
{}
{'inner_var': 100}
{'inner_var': 100}
inner_function's local is same as exec's local.
['g_var', 'test']
global is only contain g_var and function name (after excluding the special methods).
---------------------
(5, 10)
5
Videos
Well, I believe it's either an implementation bug or an undocumented design decision. The crux of the issue is that a name-binding operation in the module-scope should bind to a global variable. The way it is achieved is that when in the module level, globals() IS locals() (try that one out in the interpreter), so when you do any name-binding, it assigns it, as usual, to the locals() dictionary, which is also the globals, hence a global variable is created.
When you look up a variable, you first check your current locals, and if the name is not found, you recursively check locals of containing scopes for the variable name until you find the variable or reach the module-scope. If you reach that, you check the globals, which are supposed to be the module scope's locals.
>>> exec(compile("import sys\nprint sys._getframe().f_code.co_name", "blah", "exec"), {}, {})
<module>
>>> exec("a = 1\nclass A(object):\n\tprint a\n", {}, {})
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<string>", line 2, in <module>
File "<string>", line 3, in A
NameError: name 'a' is not defined
>>> d = {}
>>> exec("a = 1\nclass A(object):\n\tprint a\n", d,d)
1
This behavior is why inheritance worked (The name-lookup used code object's scope locals(), which indeed had A in it).
In the end, it's an ugly hack in the CPython implementation, special-casing globals lookup. It also causes some nonsensical artifical situations - e.g.:
>>> def f():
... global a
... a = 1
...
>>> f()
>>> 'a' in locals()
True
Please note that this is all my inference based on messing with the interpreter while reading section 4.1 (Naming and binding) of the python language reference. While this isn't definitive (I haven't opened CPython's sources), I'm fairly sure I'm correct about the behavior.
After print locals() and globals(),you will find the reason why exec throws "not defined" exception, and you can try this
d = dict(locals(), **globals())
exec (code, d, d)