Bug in Python class static variable?

[Duncan Booth]

Bruza <benruza at gmail.com> wrote:

> On Jul 2, 3:52 am, Duncan Booth <duncan.bo... at invalid.invalid> wrote:
>> Bruza <benr... at gmail.com> wrote:
>> > I am trying to define a class static variable. But the value of the
>> > static variable seems to be only defined inside the file that the
>> > class is declared. See the code below. When I run "python w.py", I
>> > got:
>>
>> When you run "python w.py" the *script* w.py is loaded as the module
>> __main__. Importing a module called 'w' creates a new module which is
>> unrelated to __main__. If you want access to variables defined in the
>> main script then you need to import __main__.
>>
>> Don't use 'from module import *':
>>
>> The import statements are executed when the interpreter reaches them
>> in the source. Even if you fix your code to import from __main__, the
>> values you try to import from __main__ won't exist when the import
>> statement executes: the first 'from a import *' will load and execute
>> all of module 'a', but when that executes 'from __main__ import *' it
>> just imports names defined in the main script *before* a was
>> imported. 
>>
>> In general, don't try to do this: put all your classes into modules
>> and just put minimal startup code into a script.
> 
> Duncan,
> 
> Thanks for replying. However, I am still confused...
> Even if I put "from __main__ import *" in both "a.py" and "w.py", I
> still got
> the same results. So, how should I re-structure my program to make the
> class
> static variable works???
> 
Option 1:
In w.py put:

import a

and then refer to a.ClassA

In a.py put:

import __main__

and then refer to __main__.ClassW

But better, option 2:

Create a new file script.py which contains:

import w
if __name__=='__main__':
    w.startup()

then in a use 'import w' and in w use 'import a' and refer to a.ClassA and 
w.ClassW as above.

Try to think through the order in which Python interprets your code: 
remember everything is interpreted. Both 'import' statements and 'class' 
statements are really just variation on an assignment, so none of the names 
exist until the lines which declare them have been executed. A line 'import 
a' is roughly the same as:

   a = __import__(something)

and a statement such as 'class ClassA: whatever' is roughly the same as:

  ClassA = type('ClassA', baseclasses, dict)

You should never attempt to use the 'from X import *' form of import when 
you have modules which include each other (you might get away with it if 
you move the imports to the end of the module instead of the beginning, but 
it is much simpler just to import the modules, and good practice in any 
case).