How can I access global variable inside class in Python
Question:
I have this:
g_c = 0
class TestClass():
global g_c
def run(self):
for i in range(10):
g_c = 1
print(g_c)
t = TestClass()
t.run()
print(g_c)
how can I actually modify my global variable g_c?
Answers:
By declaring it global inside the function that accesses it:
g_c = 0
class TestClass():
def run(self):
global g_c
for i in range(10):
g_c = 1
print(g_c)
The Python documentation says this, about the global statement:
The global statement is a declaration which holds for the entire current code block.
You need to move the global declaration inside your function:
class TestClass():
def run(self):
global g_c
for i in range(10):
g_c = 1
print(g_c)
The statement tells the Python compiler that any assignments (and other binding actions) to that name are to alter the value in the global namespace; the default is to put any name that is being assigned to anywhere in a function, in the local namespace. The statement only applies to the current scope.
Since you are never assigning to g_c in the class body, putting the statement there has no effect. The global statement only ever applies to the scope it is used in, never to any nested scopes. See the global statement documentation, which opens with:
The global statement is a declaration which holds for the entire current code block.
Nested functions and classes are not part of the current code block.
I’ll insert the obligatory warning against using globals to share changing state here: don’t do it, this makes it harder to reason about the state of your code, harder to test, harder to refactor, etc. If you must share a changing singleton state (one value in the whole program) then at least use a class attribute:
class TestClass():
g_c = 0
def run(self):
for i in range(10):
TestClass.g_c = 1
print(TestClass.g_c) # or print(self.g_c)
t = TestClass()
t.run()
print(TestClass.g_c)
Note how we can still access the same value from the outside, namespaced to the TestClass namespace.
I understand using a global variable is sometimes the most convenient thing to do, especially in cases where usage of class makes the easiest thing so much harder (e.g., multiprocessing). I ran into the same problem with declaring global variables and figured it out with some experiments.
The reason that g_c was not changed by the run function within your class is that the referencing to the global name within g_c was not established precisely within the function. The way Python handles global declaration is in fact quite tricky. The command global g_c has two effects:
-
Preconditions the entrance of the key "g_c" into the dictionary accessible by the built-in function, globals(). However, the key will not appear in the dictionary until after a value is assigned to it.
-
(Potentially) alters the way Python looks for the variable g_c within the current method.
The full understanding of (2) is particularly complex. First of all, it only potentially alters, because if no assignment to the name g_c occurs within the method, then Python defaults to searching for it among the globals(). This is actually a fairly common thing, as is the case of referencing within a method modules that are imported all the way at the beginning of the code.
However, if an assignment command occurs anywhere within the method, Python defaults to finding the name g_c within local variables. This is true even when a referencing occurs before an actual assignment, which will lead to the classic error:
UnboundLocalError: local variable 'g_c' referenced before assignment
Now, if the declaration global g_c occurs anywhere within the method, even after any referencing or assignment, then Python defaults to finding the name g_c within global variables. However, if you are feeling experimentative and place the declaration after a reference, you will be rewarded with a warning:
SyntaxWarning: name 'g_c' is used prior to global declaration
If you think about it, the way the global declaration works in Python is clearly woven into and consistent with how Python normally works. It’s just when you actually want a global variable to work, the norm becomes annoying.
Here is a code that summarizes what I just said (with a few more observations):
g_c = 0
print ("Initial value of g_c: " + str(g_c))
print("Variable defined outside of method automatically global? "
+ str("g_c" in globals()))
class TestClass():
def direct_print(self):
print("Directly printing g_c without declaration or modification: "
+ str(g_c))
#Without any local reference to the name
#Python defaults to search for the variable in globals()
#This of course happens for all the module names you import
def mod_without_dec(self):
g_c = 1
#A local assignment without declaring reference to global variable
#makes Python default to access local name
print ("After mod_without_dec, local g_c=" + str(g_c))
print ("After mod_without_dec, global g_c=" + str(globals()["g_c"]))
def mod_with_late_dec(self):
g_c = 2
#Even with a late declaration, the global variable is accessed
#However, a syntax warning will be issued
global g_c
print ("After mod_with_late_dec, local g_c=" + str(g_c))
print ("After mod_with_late_dec, global g_c=" + str(globals()["g_c"]))
def mod_without_dec_error(self):
try:
print("This is g_c" + str(g_c))
except:
print("Error occured while accessing g_c")
#If you try to access g_c without declaring it global
#but within the method you also alter it at some point
#then Python will not search for the name in globals()
#!!!!!Even if the assignment command occurs later!!!!!
g_c = 3
def sound_practice(self):
global g_c
#With correct declaration within the method
#The local name g_c becomes an alias for globals()["g_c"]
g_c = 4
print("In sound_practice, the name g_c points to: " + str(g_c))
t = TestClass()
t.direct_print()
t.mod_without_dec()
t.mod_with_late_dec()
t.mod_without_dec_error()
t.sound_practice()
class flag:
## Store pseudo-global variables here
keys=False
sword=True
torch=False
## test the flag class
print('______________________')
print(flag.keys)
print(flag.sword)
print (flag.torch)
## now change the variables
flag.keys=True
flag.sword= not flag.sword
flag.torch=True
print('______________________')
print(flag.keys)
print(flag.sword)
print (flag.torch)
It is very simple to make a variable global in a class:
a = 0
class b():
global a
a = 10
>>> a
10
I’d like to put together a few things I learned here (thanks to some brief but profound comments) and add my own one.
Q: How can I access a global variable from inside a class in Python?
A: By declaring it global inside the function that accesses it.
Why?: The global statement is a declaration which holds for the entire current code block. Nested functions and classes are NOT part of the current code block.
This does NOT work
class TestClass():
global global_var
def f1(self):
global_var+=1
This does work
class TestClass():
def f1(self):
global global_var
global_var+=1
However there is another ‘case/situation’.
Q: How can I access a global variable declared on another module, from inside a class in Python?
A: By importing that module and calling it ‘with the module’.
Why?: Globals belong to the module in which they are defined.
+Info on https://docs.python.org/3/reference/simple_stmts.html#the-global-statement
# module_vars.py
__all__ = ['global_var']
global_var=[]
This does NOT work
# main_program.py
from module_vars import *
class TestClass():
def f1(self):
global global_var
global_var.append(1)
This does work
# main_program.py
import module_vars
class TestClass():
def f1(self):
module_vars.global_var.append(1)
A possible formula for both cases (local & imported)
# Place wherever you are going to use the global
if not 'global_var' in globals():
log.info('global_var NOT in globals(). Try to find it in lt_globals.global_var ')
global_var=lt_globals.global_var
else:
log.info('global_var IN in globals(). Use it.')
#global global_var # This still produces> SyntaxError: name 'global_var' is assigned to before global declaration
global_var=globals()["global_var"]
A strange case.
This code (being global_var within globals())
if 'global_var' in globals():
global global_var
global_var.append(1)
Produced this error.
SyntaxError: name 'global_var' is assigned to before global declaration
I workaround it with
if 'global_var' in globals():
#global global_var # This doesn't seem to work.
global_var = globals()['global_var']
global_var.append(1)
Note: All above was tested in Python 3.7
I have this:
g_c = 0
class TestClass():
global g_c
def run(self):
for i in range(10):
g_c = 1
print(g_c)
t = TestClass()
t.run()
print(g_c)
how can I actually modify my global variable g_c?
By declaring it global inside the function that accesses it:
g_c = 0
class TestClass():
def run(self):
global g_c
for i in range(10):
g_c = 1
print(g_c)
The Python documentation says this, about the global statement:
The global statement is a declaration which holds for the entire current code block.
You need to move the global declaration inside your function:
class TestClass():
def run(self):
global g_c
for i in range(10):
g_c = 1
print(g_c)
The statement tells the Python compiler that any assignments (and other binding actions) to that name are to alter the value in the global namespace; the default is to put any name that is being assigned to anywhere in a function, in the local namespace. The statement only applies to the current scope.
Since you are never assigning to g_c in the class body, putting the statement there has no effect. The global statement only ever applies to the scope it is used in, never to any nested scopes. See the global statement documentation, which opens with:
The global statement is a declaration which holds for the entire current code block.
Nested functions and classes are not part of the current code block.
I’ll insert the obligatory warning against using globals to share changing state here: don’t do it, this makes it harder to reason about the state of your code, harder to test, harder to refactor, etc. If you must share a changing singleton state (one value in the whole program) then at least use a class attribute:
class TestClass():
g_c = 0
def run(self):
for i in range(10):
TestClass.g_c = 1
print(TestClass.g_c) # or print(self.g_c)
t = TestClass()
t.run()
print(TestClass.g_c)
Note how we can still access the same value from the outside, namespaced to the TestClass namespace.
I understand using a global variable is sometimes the most convenient thing to do, especially in cases where usage of class makes the easiest thing so much harder (e.g., multiprocessing). I ran into the same problem with declaring global variables and figured it out with some experiments.
The reason that g_c was not changed by the run function within your class is that the referencing to the global name within g_c was not established precisely within the function. The way Python handles global declaration is in fact quite tricky. The command global g_c has two effects:
-
Preconditions the entrance of the key
"g_c"into the dictionary accessible by the built-in function,globals(). However, the key will not appear in the dictionary until after a value is assigned to it. -
(Potentially) alters the way Python looks for the variable
g_cwithin the current method.
The full understanding of (2) is particularly complex. First of all, it only potentially alters, because if no assignment to the name g_c occurs within the method, then Python defaults to searching for it among the globals(). This is actually a fairly common thing, as is the case of referencing within a method modules that are imported all the way at the beginning of the code.
However, if an assignment command occurs anywhere within the method, Python defaults to finding the name g_c within local variables. This is true even when a referencing occurs before an actual assignment, which will lead to the classic error:
UnboundLocalError: local variable 'g_c' referenced before assignment
Now, if the declaration global g_c occurs anywhere within the method, even after any referencing or assignment, then Python defaults to finding the name g_c within global variables. However, if you are feeling experimentative and place the declaration after a reference, you will be rewarded with a warning:
SyntaxWarning: name 'g_c' is used prior to global declaration
If you think about it, the way the global declaration works in Python is clearly woven into and consistent with how Python normally works. It’s just when you actually want a global variable to work, the norm becomes annoying.
Here is a code that summarizes what I just said (with a few more observations):
g_c = 0
print ("Initial value of g_c: " + str(g_c))
print("Variable defined outside of method automatically global? "
+ str("g_c" in globals()))
class TestClass():
def direct_print(self):
print("Directly printing g_c without declaration or modification: "
+ str(g_c))
#Without any local reference to the name
#Python defaults to search for the variable in globals()
#This of course happens for all the module names you import
def mod_without_dec(self):
g_c = 1
#A local assignment without declaring reference to global variable
#makes Python default to access local name
print ("After mod_without_dec, local g_c=" + str(g_c))
print ("After mod_without_dec, global g_c=" + str(globals()["g_c"]))
def mod_with_late_dec(self):
g_c = 2
#Even with a late declaration, the global variable is accessed
#However, a syntax warning will be issued
global g_c
print ("After mod_with_late_dec, local g_c=" + str(g_c))
print ("After mod_with_late_dec, global g_c=" + str(globals()["g_c"]))
def mod_without_dec_error(self):
try:
print("This is g_c" + str(g_c))
except:
print("Error occured while accessing g_c")
#If you try to access g_c without declaring it global
#but within the method you also alter it at some point
#then Python will not search for the name in globals()
#!!!!!Even if the assignment command occurs later!!!!!
g_c = 3
def sound_practice(self):
global g_c
#With correct declaration within the method
#The local name g_c becomes an alias for globals()["g_c"]
g_c = 4
print("In sound_practice, the name g_c points to: " + str(g_c))
t = TestClass()
t.direct_print()
t.mod_without_dec()
t.mod_with_late_dec()
t.mod_without_dec_error()
t.sound_practice()
class flag:
## Store pseudo-global variables here
keys=False
sword=True
torch=False
## test the flag class
print('______________________')
print(flag.keys)
print(flag.sword)
print (flag.torch)
## now change the variables
flag.keys=True
flag.sword= not flag.sword
flag.torch=True
print('______________________')
print(flag.keys)
print(flag.sword)
print (flag.torch)
It is very simple to make a variable global in a class:
a = 0
class b():
global a
a = 10
>>> a
10
I’d like to put together a few things I learned here (thanks to some brief but profound comments) and add my own one.
Q: How can I access a global variable from inside a class in Python?
A: By declaring it global inside the function that accesses it.
Why?: The global statement is a declaration which holds for the entire current code block. Nested functions and classes are NOT part of the current code block.
This does NOT work
class TestClass():
global global_var
def f1(self):
global_var+=1
This does work
class TestClass():
def f1(self):
global global_var
global_var+=1
However there is another ‘case/situation’.
Q: How can I access a global variable declared on another module, from inside a class in Python?
A: By importing that module and calling it ‘with the module’.
Why?: Globals belong to the module in which they are defined.
+Info on https://docs.python.org/3/reference/simple_stmts.html#the-global-statement
# module_vars.py
__all__ = ['global_var']
global_var=[]
This does NOT work
# main_program.py
from module_vars import *
class TestClass():
def f1(self):
global global_var
global_var.append(1)
This does work
# main_program.py
import module_vars
class TestClass():
def f1(self):
module_vars.global_var.append(1)
A possible formula for both cases (local & imported)
# Place wherever you are going to use the global
if not 'global_var' in globals():
log.info('global_var NOT in globals(). Try to find it in lt_globals.global_var ')
global_var=lt_globals.global_var
else:
log.info('global_var IN in globals(). Use it.')
#global global_var # This still produces> SyntaxError: name 'global_var' is assigned to before global declaration
global_var=globals()["global_var"]
A strange case.
This code (being global_var within globals())
if 'global_var' in globals():
global global_var
global_var.append(1)
Produced this error.
SyntaxError: name 'global_var' is assigned to before global declaration
I workaround it with
if 'global_var' in globals():
#global global_var # This doesn't seem to work.
global_var = globals()['global_var']
global_var.append(1)
Note: All above was tested in Python 3.7