A scoping question

[It's me]

This must be another newbie gotchas.

Consider the following silly code, let say I have the following in file1.py:

#=============
import file2
global myBaseClass
myBaseClass = file2.BaseClass()
myBaseClass.AddChild(file2.NextClass())
#=============

and in file2.py, I have:

#=============
global myBaseClass
class BaseClass:
def __init__(self):
self.MyChilds = []
...
def AddChild(NewChild):
self.MyChilds.append(NewChild)
...
class NextClass:
def __init__(self):
for eachChild in myBaseClass.MyChilds: # <- ERROR
...
#=============

When I run this, Python complains that myBaseClass is undefined in the last
line above.

What am I doing wrong? (Yes, I know I am thinking too much in C). I
thought the global declaration would have been sufficient but it's obviously
not.

Thanks,

 

[Premshree Pillai]

This must be another newbie gotchas.

Consider the following silly code, let say I have the following in file1.py:

#=============
import file2
global myBaseClass
myBaseClass = file2.BaseClass()
myBaseClass.AddChild(file2.NextClass())
#=============

You have declared myBaseClass to be global, but it doesn't exist.

Consider the following code:

global name
print name.__len__()

This will return a NamError

However, the following code will run just fine:

global name
name = "python"
print name.__len__()

will return 6

and in file2.py, I have:

#=============
global myBaseClass
class BaseClass:
def __init__(self):
self.MyChilds = []
...
def AddChild(NewChild):
self.MyChilds.append(NewChild)
...
class NextClass:
def __init__(self):
for eachChild in myBaseClass.MyChilds: # <- ERROR
...
#=============

When I run this, Python complains that myBaseClass is undefined in the last
line above.

What am I doing wrong? (Yes, I know I am thinking too much in C). I
thought the global declaration would have been sufficient but it's obviously
not.

Thanks,

HTH

 

[It's me]

You have declared myBaseClass to be global, but it doesn't exist.

No, myBaseClass exists in file1.py. The question is how can I tell
file2.py that the global variable is in file1 (without doing a silly
file1.myBaseClass....

Since I am invoking file2 from file1, I would have thought that global
variables in file1 exists automatically....(too much C thinking, I know)

 

[Premshree Pillai]

No, myBaseClass exists in file1.py. The question is how can I tell

Umm, from the sample code (for file2.py) that you provided, I don't
see myBaseClass. You've only declared it to be global in file2.py, but
it does not exist -- does not exist in the sense that it has no type
associated with it, which in turn means meaning you cannot apply
methods to it.

 

[Steven Bethard]

This must be another newbie gotchas.

Consider the following silly code, let say I have the following in file1.py:

#=============
import file2
global myBaseClass
myBaseClass = file2.BaseClass()
myBaseClass.AddChild(file2.NextClass())
#=============

and in file2.py, I have:

#=============
global myBaseClass
class BaseClass:
def __init__(self):
self.MyChilds = []
...
def AddChild(NewChild):
self.MyChilds.append(NewChild)
...
class NextClass:
def __init__(self):
for eachChild in myBaseClass.MyChilds: # <- ERROR
...
#=============

When I run this, Python complains that myBaseClass is undefined in the last
line above.

What am I doing wrong? (Yes, I know I am thinking too much in C). I
thought the global declaration would have been sufficient but it's obviously
not.

I think you're confused about what the global keword does. Declaring a
name as global makes that name global *to the module*:

http://docs.python.org/ref/global.html
http://docs.python.org/lib/built-in-funcs.html#l2h-32

What you probably want instead is:

-------------------- file1.py --------------------
import file2
myBaseClass = file2.BaseClass()
myBaseClass.AddChild(file2.NextClass())
--------------------------------------------------

-------------------- file2.py --------------------
class BaseClass:
def __init__(self):
self.MyChilds = []
def AddChild(self, NewChild):
self.MyChilds.append(NewChild)
class NextClass:
def __init__(self):
from file1 import myBaseClass # IMPORT
for eachChild in myBaseClass.MyChilds:
pass
--------------------------------------------------

Note that I import myBaseClass in __init__. If I imported it at the top
of the module, then file1 would import file2 which would then import
file1 and you'd have a circular dependency.

As it is, your code is very tightly coupled. Why don't you put all this
code into a single module?

Steve

 

[Steven Bethard]

This must be another newbie gotchas.

Consider the following silly code

[snip tightly coupled code]

A few options that also might work better than such tightly coupled modules:

-------------------- file1.py --------------------
import file2
myBaseClass = file2.BaseClass()
class NextClass:
def __init__(self):
for eachChild in myBaseClass.MyChilds:
pass
myBaseClass.AddChild(file2.NextClass())
--------------------------------------------------

-------------------- file2.py --------------------
class BaseClass:
def __init__(self):
self.MyChilds = []
def AddChild(self, NewChild):
self.MyChilds.append(NewChild)
--------------------------------------------------


or


-------------------- file1.py --------------------
import file2
myBaseClass = file2.BaseClass()
myBaseClass.AddChild(file2.NextClass(myBaseClass))
--------------------------------------------------

-------------------- file2.py --------------------
class BaseClass:
def __init__(self):
self.MyChilds = []
def AddChild(self, NewChild):
self.MyChilds.append(NewChild)
class NextClass:
def __init__(self, myBaseClass):
for eachChild in myBaseClass.MyChilds:
pass
--------------------------------------------------

 

[It's me]

Thanks, Steve.

So, global is only to within a module (I was afraid of that). Those words
flashed by me when I was reading it but since the word "module" didn't
translate to "file" in my C mind, I didn't catch that.

In that case, you are correct that I have to do an import of file1 in file2.

Not that this is not real code, I am still trying to learn the ins and outs
of Python by writing some silly code - but will be important to help me
understand how I would write the real code.

Regarding the question of not placing everything in one module, I wouldn't
think that that's how I would do it. I might get ambitous later and write
code for a larger project. In that case, I will need to know more about
scoping across multiple modules. So, this helps me understand what to do.

Thanks again.

 

[Steven Bethard]

#=============
import file2
global myBaseClass
myBaseClass = file2.BaseClass()
myBaseClass.AddChild(file2.NextClass())
#============= [snip]
#=============
global myBaseClass
class BaseClass:
def __init__(self):
self.MyChilds = []
...
def AddChild(NewChild):
self.MyChilds.append(NewChild)
...
class NextClass:
def __init__(self):
for eachChild in myBaseClass.MyChilds: # <- ERROR
...
#=============

Also worth mentioning if you're just starting with Python. Python has
some official naming conventions:

http://www.python.org/peps/pep-0008.html

These are just recommendations of course, but if you have the option
(e.g. you're not constrained by style enforced by your employer), and
you'd like your code to look more like standard Python modules, you
might consider using these suggestions. This would make your code look
something like:

#=============
import file2
global my_base_class
my_base_class = file2.BaseClass()
my_base_class.add_child(file2.NextClass())
#=============

#=============
global my_base_class
class BaseClass:
def __init__(self):
self.my_childs = []
...
def add_child(new_child):
self.my_childs.append(new_child)
...
class NextClass:
def __init__(self):
for each_child in my_base_class.my_childs: # <- ERROR
...
#=============

Steve

 

[Dennis Lee Bieber]

This must be another newbie gotchas.

Consider the following silly code, let say I have the following in file1.py:

#=============
import file2
global myBaseClass

#1 "global" only applies within a function definition,
where it signals that the subsequent name will be modified within the
function AND exists in the scope external to the function... If the
object name ONLY appears on the right side of an assignment (within the
function), "global" is not needed, as the scope rules will look-up the
external item. However, if the object name appears on the left hand
side, and there is NO "global", Python creates a local object (and will
then complain if you used the name on a right-side before the assignment
creating it).

aGlobalItem = [1, 2, 3]

def aFunction():
global aGlobalItem
aGlobalItem = ('a', 'b', 'c')
return None

Without the "global", the function would create a function-local
called aGlobalItem, and never see the outside object.

myBaseClass = file2.BaseClass()
myBaseClass.AddChild(file2.NextClass())
#=============

and in file2.py, I have:

#=============
global myBaseClass
class BaseClass:
def __init__(self):
self.MyChilds = []
...
def AddChild(NewChild):
self.MyChilds.append(NewChild)
...
class NextClass:
def __init__(self):
for eachChild in myBaseClass.MyChilds: # <- ERROR
...
#=============

When I run this, Python complains that myBaseClass is undefined in the last
line above.

Which is correct. "global" only works within function
definitions /within/ a module (file). To access stuff in other modules
you must "import" the module.

What am I doing wrong? (Yes, I know I am thinking too much in C). I
thought the global declaration would have been sufficient but it's obviously
not.

#2 You are trying to create a set of recursive
dependencies. File1 is getting an object definition from File2, but
File2 needs the object created in File1...

Terrible design, IMHO...


And why is NextClass a "class"? Does it return a "NextClass"
object?

Either way... I'd probably change the __init__ to take two
arguments: self (which is the NextClass object being created) and 'o'
(the other argument), then use it as

nc = NextClass(myBaseClass)

--