Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

Python: Sharing global variables between modules and classes therein

I know that it's possible to share a global variable across modules in Python. However, I would like to know the extent to which this is possible and why. For example,

global_mod.py

x = None 

mid_access_mod.py

from global_mod import *  class delta:     def __init__(self):         print x 

bot_modif_mod.py

import mid_access_mod import global_mod  class mew:     def __init__(self):         global_mod.x = 5  def main():     m = mew()     d = mid_access_mod.delta() 

This prints None, even though all the modules are sharing the global variable x. Why is this the case? It seems like x is evaluated at mid_access_mod.py before it is assigned in bot_modif_mod.py by mew().

like image 522
emish Avatar asked Jul 26 '10 19:07

emish


People also ask

How can you share global variables across modules in Python?

The best way to share global variables across modules across a single program is to create a config module. Just import the config module in all modules of your application; the module then becomes available as a global name.

Are global variables shared between modules?

Can I have a shared global variable across different files? As we discussed, the global variable is unique to its own module.

Can classes access global variables Python?

As shown below, global variables can be accessed by any class or method within a class by simply calling the variable's name. Global variables can also be accessed by multiple classes and methods at the same time.

Can global variables be shared between processes and threads?

Yes, a thread who lives in the same process can access a global variable, but you must ensure the safety of any memory that is accessed by multiple threads.


1 Answers

This happens because you are using immutable values (ints and None), and importing variables is like passing things by value, not passing things by reference.

If you made global_mod.x a list, and manipulated its first element, it would work as you expect.

When you do from global_mod import x, you are creating a name x in your module with the same value as x has in global_mod. For things like functions and classes, this works as you would expect, because people (generally) don't re-assign to those names later.

As Alex points out, if you use import global_mod, and then global_mod.x, you will avoid the problem. The name you define in your module will be global_mod, which always refers to the module you want, and then using attribute access to get at x will get you the latest value of x.

like image 69
Ned Batchelder Avatar answered Sep 21 '22 11:09

Ned Batchelder