Python function global variables?

Python function global variables?

If you want to simply access a global variable you just use its name. However to change its value you need to use the global keyword.

E.g.

global someVar
someVar = 55

This would change the value of the global variable to 55. Otherwise it would just assign 55 to a local variable.

The order of function definition listings doesnt matter (assuming they dont refer to each other in some way), the order they are called does.

Within a Python scope, any assignment to a variable not already declared within that scope creates a new local variable unless that variable is declared earlier in the function as referring to a globally scoped variable with the keyword global.

Lets look at a modified version of your pseudocode to see what happens:

# Here, were creating a variable x, in the __main__ scope.
x = None!

def func_A():
  # The below declaration lets the function know that we
  #  mean the global x when we refer to that variable, not
  #  any local one

  global x
  x = A
  return x

def func_B():
  # Here, we are somewhat mislead.  Were actually involving two different
  #  variables named x.  One is local to func_B, the other is global.

  # By calling func_A(), we do two things: were reassigning the value
  #  of the GLOBAL x as part of func_A, and then taking that same value
  #  since its returned by func_A, and assigning it to a LOCAL variable
  #  named x.     
  x = func_A() # look at this as: x_local = func_A()

  # Here, were assigning the value of B to the LOCAL x.
  x = B # look at this as: x_local = B

  return x # look at this as: return x_local

In fact, you could rewrite all of func_B with the variable named x_local and it would work identically.

The order matters only as far as the order in which your functions do operations that change the value of the global x. Thus in our example, order doesnt matter, since func_B calls func_A. In this example, order does matter:

def a():
  global foo
  foo = A

def b():
  global foo
  foo = B

b()
a()
print foo
# prints A because a() was the last function to modify foo.

Note that global is only required to modify global objects. You can still access them from within a function without declaring global.
Thus, we have:

x = 5

def access_only():
  return x
  # This returns whatever the global value of x is

def modify():
  global x
  x = modified
  return x
  # This function makes the global x equal to modified, and then returns that value

def create_locally():
  x = local!
  return x
  # This function creates a new local variable named x, and sets it as local,
  #  and returns that.  The global x is untouched.

Note the difference between create_locally and access_only — access_only is accessing the global x despite not calling global, and even though create_locally doesnt use global either, it creates a local copy since its assigning a value.

The confusion here is why you shouldnt use global variables.

Python function global variables?

As others have noted, you need to declare a variable global in a function when you want that function to be able to modify the global variable. If you only want to access it, then you dont need global.

To go into a bit more detail on that, what modify means is this: if you want to re-bind the global name so it points to a different object, the name must be declared global in the function.

Many operations that modify (mutate) an object do not re-bind the global name to point to a different object, and so they are all valid without declaring the name global in the function.

d = {}
l = []
o = type(object, (object,), {})()

def valid():     # these are all valid without declaring any names global!
   d[0] = 1      # changes whats in d, but d still points to the same object
   d[0] += 1     # ditto
   d.clear()     # ditto! d is now empty but it`s still the same object!
   l.append(0)   # l is still the same list but has an additional member
   o.test = 1    # creating new attribute on o, but o is still the same object