globals and locals in python exec()

by

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.

More Related Contents:

  1. Using global variables in a function
  2. Local variables in nested functions
  3. Accessing class variables from a list comprehension in the class definition
  4. Python 3: UnboundLocalError: local variable referenced before assignment [duplicate]
  5. Variable scopes in Python classes
  6. How do I create a list of lambdas (in a list comprehension/for loop)?
  7. What’s the scope of a variable initialized in an if statement?
  8. Why does this UnboundLocalError occur (closure)? [duplicate]
  9. Nested classes’ scope?
  10. Block scope in Python
  11. except-clause deletes local variable
  12. Advanced Nested List Comprehension Syntax
  13. Python: How can I run eval() in the local scope of a function
  14. Creating a class within a function and access a function defined in the containing function’s scope
  15. Python – Why is this class variable not defined in the method?
  16. How to inject variable into scope with a decorator?
  17. Python: Sharing global variables between modules and classes therein
  18. Tensorflow: How to get a tensor by name?
  19. Why is one class variable not defined in list comprehension but another is?
  20. The scope of names defined in class block doesn’t extend to the methods’ blocks. Why is that?
  21. Getting “global name ‘foo’ is not defined” with Python’s timeit
  22. How references to variables are resolved in Python [duplicate]
  23. What is the scope of a defaulted parameter in Python?
  24. Global dictionaries don’t need keyword global to modify them? [duplicate]
  25. Access self from decorator
  26. Why do I get a `NameError` (or `UnboundLocalError`) from using a named exception after the `except` block?
  27. UnboundLocalError trying to use a variable (supposed to be global) that is (re)assigned (even after first use)
  28. Python global variable scoping
  29. Why can functions in Python print variables in enclosing scope but cannot use them in assignment? [duplicate]
  30. Scope of variable within “with” statement?

Leave a Comment