Best practice: Sharing object between different objects

[sohcahtoa82 at gmail.com]

On Monday, February 23, 2015 at 10:45:59 AM UTC-8, Michael Torrie wrote:
> On 02/23/2015 11:10 AM, Rob Gaddi wrote:
> > So I'd solve it with module level global variables.  It's semi-frowned 
> > upon on software stuff because it creates an unintentional shared state 
> > between different modules, but you really HAVE a shared state, so it 
> > needs to be dealt with.
> 
> I would also do it with a module attribute.  In my mind that's exactly
> the right way to go.
> 
> But I disagree that it's frowned on or a bad thing. A module is a
> completely appropriate place to store state.  In fact a module is an
> object, but a special one that can only be instantiated once.  So as far
> as patterns go, a module is a singleton. Almost any time in Python you
> have something that you want to have exactly one instance of in your
> program, you don't want to define a class but rather just use a module.
> 
> Any code in a module can be considered the constructor. It executes only
> once in your program when the module is first imported, no matter how
> many times its imported after that.
> 
> I often use a module to store configuration that is shared across
> modules in my projects.

That behavior always trips me up.  My intuition tells me that every time you import a module, it re-runs the code in the module.  So if I had a simple module named myModule.py that had a single line with `myInt = 1`, then I would *EXPECT* this behavior:

>>> import myModule
>>> myModule.myInt
1
>>> myModule.myInt = 2
>>> myModule.myInt
2
>>> import myModule
>>> myModule.myInt
1

It seems slightly counter-intuitive, but the *ACTUAL* behavior (where the final line prints 2) does allow for something nice: Easy use of global variables.

What's REALLY interesting is that this happens:

>>> import myModule
>>> myModule.myInt
1
>>> myModule.myInt = 2
>>> myModule.myInt
2
>>> del myModule
>>> import myModule
>>> myModule.myInt
2

I would REALLY expect that deleting the module object and then re-importing would reset that variable.  And then...

>>> del myModule.myInt
>>> del myModule
>>> import myModule
>>> myModule.myInt
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'module' object has no attribute 'myInt'

So yeah...modules are really only loaded once unless you use reload/imp.reload/importlib.reload.

But yeah, it seems slightly counter-intuitive to me at first, but certainly has its uses.