Variables declared outside function [duplicate]

Question

Possible Duplicate:
referenced before assignment error in python
local var referenced before assignment

I was just trying to see how variable scopes work and ran into the following situation (all ran from the terminal):

x = 1 def inc():     x += 5  inc() Traceback (most recent call last):   File "<stdin>", line 1, in <module>   File "<stdin>", line 2, in inc UnboundLocalError: local variable 'x' referenced before assignment 

I was thinking maybe I don't have access to x in my method, so I tried:

def inc():     print(x)  1 

So this works. Now I know I could just do:

 def inc():      global x      x += 1 

And this would work, but my question is why does the first example fail? I mean I would expect since print(x) worked that x is visible inside the function so why would the x += 5 fail?

Answer 1

Unlike languages that employ 'true' lexical scoping, Python opts to have specific 'namespaces' for variables, whether it be global, nonlocal, or local. It could be argued that making developers consciously code with such namespaces in mind is more explicit, thus more understandable. I would argue that such complexities make the language more unwieldy, but I guess it's all down to personal preference.

Here are some examples regarding global:-

>>> global_var = 5 >>> def fn(): ...     print(global_var) ...  >>> fn() 5 >>> def fn_2(): ...     global_var += 2 ...     print(global_var) ...  >>> fn_2() Traceback (most recent call last):   File "<stdin>", line 1, in <module>   File "<stdin>", line 2, in fn_2 UnboundLocalError: local variable 'global_var' referenced before assignment >>> def fn_3(): ...     global global_var ...     global_var += 2 ...     print(global_var) ...  >>> fn_3() 7 

The same patterns can be applied to nonlocal variables too, but this keyword is only available to the latter Python versions.

In case you're wondering, nonlocal is used where a variable isn't global, but isn't within the function definition it's being used. For example, a def within a def, which is a common occurrence partially due to a lack of multi-statement lambdas. There's a hack to bypass the lack of this feature in the earlier Pythons though, I vaguely remember it involving the use of a single-element list...

Note that writing to variables is where these keywords are needed. Just reading from them isn't ambiguous, thus not needed. Unless you have inner defs using the same variable names as the outer ones, which just should just be avoided to be honest.