local namespace vs. global namespace

[Skaperen]

Output:
globals()['pv'] = <function pv at 0x7f303a969268>
Traceback (most recent call last):
 File "launch.py", line 760, in <module>
   result=main(argv)
 File "launch.py", line 386, in main
   print('pv =',repr(pv),file=stderr)
UnboundLocalError: local variable 'pv' referenced before assignment
lt1/ph_use1 /home2/ph_use1 12> head -n390 launch.py|tail
       print(file=stderr)
       print('globals() =',repr(sorted(globals().keys())),file=stderr)
       print('globals() =',repr(sorted(globals().items())),file=stderr)
       print(file=stderr)
       print("globals()['pv'] =",repr(globals()['pv']),file=stderr)
       print('pv =',repr(pv),file=stderr)
       pv('arg','parts')
       name = 'xy'
       if arg[0] == '@':
           name, value = 'se', arg[1:]

i am defining a function named "pv" in the global namespace, where they usually get defined, but in this case, it is there, but not being found.  the exception "UnboundLocalError: local variable 'pv' referenced before assignment" has the word local, twice, suggesting that this is happening in some context where it knows it is only going to the local namespace and ignoring the global namespace.  what am i doing wrong?  i want the normal behavior of looking up names in both local an global namespaces.


FYI, the function is defined in this code, not imported from a module.

[micseydel]

Can you provide a minimal snippet that reproduces the problem?

[Skaperen]

no,  i have tried to re-create the problem but all other code attempts work correctly. i am wanting to understand where this particular message comes from. the message itself is suspicious.

[Larz60+]

If you are running cpython, you will probably find the error is generated in
one of the following files:
ceval.c
compile.c
memoryobject.c
symtable.c
(or one of their include files)

[Skaperen]

i found code in my big script (some 700 lines) that when removed, fixed it.  that code was a conditional re-def of pv() to do nothing.  it did not meet the condition in my runs and so, the function did not get redefined.  because the code (technically an assignment) existed, python (cpython?) considered that name to be local, so any reference would not look further to the global namespace when it didn't find it in the local namespace.

the following is an example (try it):

x = 6
def main():
   if False:
       x = 7
   print(x)
main()

do you expect to get 6?  you won't

FYI, pv() is a debugging tool in my script (it prints a variable given its name).  that re-def code was intended to make it do nothing if the "nodebug" environment variable was set (to any value).  that way i could easily run the script without all those debug messages whenever i wanted to.

more reading: http://eli.thegreenplace.net/2011/05/15/...-in-python

[snippsat]

Variable x = 6 in global namespace should never exists.
The try to use it some function.
Global variables are bad in any programming language

Terrible:

x = 5
def func_add():
   return x + 6

print(func_add()) #--> 11

The right way,5 is given as as a argument to the function.

def func_add(arg):
   return arg + 6

print(func_add(5)) #--> 11

[Mekire]

do you expect to get 6?  you won't

No, actually I don't. I expect exactly what happens which is an UnboundLocalError.

Variables aren't bound to the scope of a function upon their specific execution. Having a name that sometimes referred to a local and sometimes a global based on the value of some Boolean would be horrendous; and thankfully it doesn't work this way. If you want the variable local make sure it is defined locally and declare it global if that is what you want (or rather, don't).

I do remember a previous thread that talked more about the why of this in detail and perhaps Casevh will pop up with a more concrete response, but basically, as far as I know the scope of variables is determined at initial runtime, not at the time we think of that code as actually being executed. Your program knows that the way x is being used in that function makes it local despite it never getting assigned.

[metulburr]

Cant say much more than snippsat and mekire already had. If your following PEP 8 guidelines, you shouldnt have a global variable named x. It should be capped to signify it being a global variable and passed into a global function like snippsat described as well as more descriptive. Or you should have global keyword to execute it as such, but as well to blatantly portray it as global. After much of that you usually find your code littered with globals. I usually be rid of globals by encapsulating much of my stuff in classes. I mean there are sometimes when an object is too much, but a lot of times can get rid of the global junk. In your example a main function is too much and you will turn yourself into a java programmer.

[Skaperen]

the UnboundLocalError problem happens with function definitions, too.

the little 6 line example i showed used a plain assignment just to make the example short and simple.  but since you guys didn't get it and focused on what you could find wrong in the example instead of what it illustrates, i'll make a better version that ends up being longer.  this is an example illustrating the UnboundLocalError problem. although this is bad code, it is a minimalist example of a realistic attempt at debugging.  when coders are trying to debug other problems (not the UnboundLocalError problem), temporarily added code is generally not of concern since it is expected to be remove before release. so here is the 12 line (plus 3 blank lines for easier reading) example showing the UnboundLocalError problem.

from __future__ import print_function
import sys

def debugprint(a):
   print(a,file=sys.stderr)
   return

def main(args):
   if '--nodebug' in args:
       def debugprint(a):
           return
   debugprint('args =',repr(args))
   return 0

exit(main(sys.argv))

[ichabod801]

from __future__ import print_function
import sys
 
def debugprint(a):
   print(a,file=sys.stderr)
   return
 
def main(args):
   debugprint('args =',repr(args))
   return 0
 
if __name__ == '__main__':
   args = sys.argv
   if '--nodebug' in args:
       def debugprint(a):
           return
   exit(main(args))