1

So I was using Python 2.7.15 and I was running into an unexpected error with using global variable inside local scopes function. I know I can get around using "gloabl foo" (I know, not recommended) inside my function, but the error I was expected was not on line number I was expecting.

Code working as expected:

foo = 123

def fooBar():
  print foo   ### cannot find foo from local scope, checks prev and prints 123

  ##  TEST 2  ##
  #foo=987
  #print foo    

fooBar()

But when I change the code to the following I would expect the same print as Test #1, but instead it blows up on the print statement: 

foo = 123

 def fooBar():
      print foo   ### blows up here... 

      ##  TEST 2  ##
      foo=987
      print foo    

fooBar() 

Traceback (most recent call last):
  File "python", line 9, in <module>
  File "python", line 4, in fooBar
UnboundLocalError: local variable 'foo' referenced before assignment

I was assuming it would still print '123' and then blow up when I try to assign another value to foo. Almost like Python interpreter parses fooBar() and knows I do an assignment of foo later in local function and then blows up on the print, instead of grabbing global value??

Thanks in Advance! -Kevin

Gassa
  • 7,799
  • 3
  • 28
  • 47
KevinSoltis
  • 11
  • 2
  • 1
    the linked duplicate is really close, and the accepted answer explains exactly this interesting point. The byte-compiler sees the use of `foo` as local, thus it uses this local reference in the whole function. So it's not as dynamic as we thought (I learned that myself very recently) – Jean-François Fabre May 30 '18 at 11:27
  • 1
    Local variables are defined at function level, and their names exist since the beginning of the function. `print foo` in the second snippet refers always to the local `foo` which, at the point of the first line, has not been assigned any value yet. – jdehesa May 30 '18 at 11:28
  • 2
    FWIW : "Almost like Python interpreter parses fooBar() and knows I do an assignment of foo later in local function" is __exactly__ what happens. Python is dynamic indeed but it's still compiled to bytecode (just like Java), not naiveley interpreted line-by-line like you might believe. – bruno desthuilliers May 30 '18 at 11:28
  • 2
    Your theory is correct. The first version works because Python can't find `foo` in `fooBar`'s locals, so it looks in the globals. But in the 2nd version it knows that `foo` must be local to `fooBar` because it makes an assignment to it, and there's no `global` directive. – PM 2Ring May 30 '18 at 11:28
  • I'm on board but one other question: in the above example foo's a primitive type, and if I change to a list and change foo=987 to foo.append(987) it works. So when the byte-compiler compiles does it check global or does it just check primitive assignemtns? Works: foo = [1] def fooBar(): print foo foo.append(2) print foo fooBar() – KevinSoltis May 30 '18 at 12:28
  • @KevinSoltis the compiler checks for *any assignment* and marks the *variable* as local. Note, **there are no primitive types in Python** – juanpa.arrivillaga Jun 09 '18 at 00:29

0 Answers0