How to change a global variable from within a function?

The error that you get when you try to run your code is:

UnboundLocalError: local variable 'a' referenced before assignment

… which, on the face of it, seems strange: after all, the first statement in the code above (a = 15) is an assignment. So, what's going on?

Actually, there are two distinct things happening, and neither of them are obvious unless you already know about them.

First of all, you actually have two different variables:

• The a in your first line is a global variable (so called because it exists in the global scope, outside of any function definitions).

• The a in the other lines is a local variable, meaning that it only exists inside your test() function.

These two variables are completely unrelated to each other, even though they have the same name.

A variable is local to a function if there's a statement assigning to it inside that function - for instance, your a = a +10 line.

Even so, the error still looks strange - after all, the very first thing you do inside test() is assign to a, so how can it be referenced beforehand?

The answer is that, in an assignment statement, Python evaluates everything on the right hand side of the = sign before assigning it to the name on the left hand side – so even though the assignment is written first in your code, a gets referenced first in that right hand side: a +10.

There are two ways you can get around this. The first is to tell Python that you really want the a inside test() to be the same a in the global scope:

def test():    global a    a = a + 10    print(a)

This will work, but it's a pretty bad way to write programs. Altering global variables inside functions gets hard to manage really quickly, because you usually have lots of functions, and none of them can ever be sure that another one isn't messing with the global variable in some way they aren't expecting.

A better way is to pass variables as arguments to functions, like this:

a = 15def test(x):    x = x + 10    print(x)test(a)

Notice that the name doesn't have to be the same - your new definition of test() just says that it accepts a value, and then does something with it. You can pass in anything you like – it could be a, or the number 7, or something else. In fact, your code will always be easier to understand if you try to avoid having variables with the same name in different scopes.

If you play with the code above, you'll notice something interesting:

>>> a = 15>>> test(a)25>>> a15

… a didn't change! That's because although you passed it into test() and it got assigned to x, it was then x that got changed, leaving the original a alone.

If you want to actually change a, you need to return your modified x from the function, and then reassign it back to a on the outside:

>>> a = 15>>> >>> def test(x):...     x = x + 10...     print(x)...     return x... >>> a = test(a)25>>> a25

I would do it this way:

def test(a):    a = a +10    return aprint(test(15))

Note that in the version hereby proposed there are some things differing from yours.

First, what I wrote down would create a function that has, as an input, the value a (in this case set to 15 when we call the function -already defined in the last line-), then assigns to the object a the value a (which was 15) plus 10, then returns a (which has been modified and now is 25) and, finally, prints a out thanks to the last line of code:

print(test(15))

Note that what you did wasn't actually a pure function, so to speak. Usually we want functions to get an input value (or several) and return an input value (or several). In your case you had an input value that was actually empty and no output value (as you didn't use return). Besides, you tried to write this input a outside the function (which, when you called it by saying test(a) the value a was not loaded an gave you the error -i.e. in the eyes of the computer it was "empty").

Furthermore, I would encourage you to get used to writing return within the function and then using a print when you call it (just like I wrote in the last coding line: print(test(15))) instead of using it inside the function. It is better to use print only when you call the function and want to see what the function is actually doing.

At least, this is the way they showed me in basic programming lessons. This can be justified as follows: if you are using the return within the function, the function will give you a value that can be later used in other functions (i.e. the function returns something you can work with). Otherwise, you would only get a number displayed on screen with a print, but the computer could not further work with it.

P.S. You could do the same doing this:

def test(a):    a +=10          return aprint(test(15))

You're modifying a variable a created in the scope of the function test(). If you want the outter a to be modified you could do:

a = 15def test():    global a    a = a + 1    print(a)test()