0

Why can't I declare a function in exec within another function ? I really have no idea why it's happening, is there a way to make this work. I found this: Invoking problem with function defined in exec() but it's not exactly what I'm looking for, in my case I wan't the exec code to be arbitrary.

def test():
    exec("""
def this():
    print('this')

def main():
    this()

main()
""")

test()

Returns:

Traceback (most recent call last):
  File "/t.py", line 12, in <module>
    test()
  File "/t.py", line 2, in test
    exec("""
  File "<string>", line 8, in <module>
  File "<string>", line 6, in main
NameError: name 'this' is not defined

When I do the exec outside a function it works just fine, why ? :

exec("""
def this():
    print('this')

def main():
    this()

main()
""")
Improve this question
5
  • Please clarify your specific problem or provide additional details to highlight exactly what you need. As it's currently written, it's hard to tell exactly what you're asking. Commented Mar 21, 2022 at 15:34
  • Not sure why, but it works if you add an empty dictionary as globals to exec. What exactly do you want to achieve with this, or is just purely out of academic interest? Commented Mar 21, 2022 at 15:37
  • 1
    this and main are both defined in the local scope of test, but main still looks in the global scope for the definition of this. When you pass a dict, that is used as the namespace, so the call to main will look there instead for the definition of this. Commented Mar 21, 2022 at 15:53
  • Be very sure you need exec before worrying about this, though. Just because (you think) you can use exec doesn't mean you should be using it. Commented Mar 21, 2022 at 15:54
  • Yes thank you, I didn't know about namespace dict in exec. And that was purely out of curiosity. Commented Mar 22, 2022 at 9:51

2 Answers 2

Reset to default
0

TLDR: Provide explicit globals dictionaries to execute code "as if" it were run at top-level.

Python uses lexical scoping, which roughly means that names are looked up as per the nesting in source code. For example, a nested function can access an outer function's variable.

def foo():
    bar = 12
    def qux():
        print(bar)  # nested scope accesses outer scope
    return qux

Notably, this kind of name lookup happens at source code compilation time – the compiler knows that both foo and qux access bar, so it must be made available to both. The inner function is directly compiled to look at the variable of the outer function.

If instead a function is not nested, its name lookup to non-local variables automatically goes to global scope.

def qux():
    print(bar)  # top-level scope accesses global scope

This is a problem when we exec code in a function: A definition such as def main(): this() is compiled to lookup this at global scope, but exec runs in the current local scope of the function.

In all cases, if the optional parts are omitted, the code is executed in the current scope.

Thus, this is looked up globally but defined locally.1 The compiler parses def test and the exec code separately, so it does not know that lookups are meant to be treated as nested.
As a result, the lookup fails.

In order to exec code "as if" it were run at top-level, it is sufficient to supply an explicit globals – for example a fresh namespace {} or the actual globals().

def test():
    exec("""
def this():
    print('this')

def main():
    this()

main()
""", {})
#    ^^ globals namespace for exec

test()

This means the code is now run in (its own) global namespace, which is where the lookup of functions searches as well.

1This can be checked by printing globals()/locals() and by inspecting the instructions of the function. dis.dis(main) in the exec would produce:

  6           0 LOAD_GLOBAL              0 (this)
              2 CALL_FUNCTION            0
              4 POP_TOP
              6 LOAD_CONST               0 (None)
              8 RETURN_VALUE
Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

0

heres my attempt to make it work
from the error, i am guessing you can create an object by using exec() in global environment, but cant add an object to global environment using exec() in a function. thus the system sees it as a local exec() variable and failed to read it
so i tried to add a global declaration and it worked:

def test():
    exec("""
global this
def this():
    print('this')

def main():
    this()

main()
""")

test()

results:

this

however it may overwrite other global variables because i can now call this() outside of test():

>>> this()
this
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.