cannot find object instance

[Bruno Desthuilliers]

jimgardener a écrit :
> hi,
> i am a python newbie..

 From what I can see from your code, you're a newbie to programming in 
general...

> while trying out some message passing between
> two object instances i came across a problem

First point : you have both a circular dependency between ModuleA and 
ModuleB - which is better to avoid unless you really like headaches... 
You mention Java somewhere else, so I assume you have some at least some 
Java background. Point here is that Python is not Java, and doesn't 
restrict you to one ("public") class per module. IOW, if you have two 
strongly related classes (which is obviously the case here), better to 
put both in a same module.

> moduleA.py
> --------------------
> import moduleB
> class MyClassA:
>     def __init__(self):
>         self.age=0
>         self.address=''
>     def createClassB(self):
>         self.objB=moduleB.MyClassB()

Why is this in a distinct method instead of being in the initializer ? 
And why is it named create*Class* when it creates an *instance* ?

>     def validate(self,age,address):
>         if(age >= 100 or address==''):
>             self.age=20;
>             self.address="Broadway,NewYork"
>         self.objB.display(self.age,self.address)
>     def callB(self):
>         self.objB.execute()

Looks like a somewhat messy, circonvoluted and arbitrary 
overcomplexificated control flow...

> if __name__ == "__main__":
>     objA=MyClassA()
>     objA.createClassB()
>     objA.callB()
> 
> moduleB.py
> ------------------
> import moduleA
> 
> class MyClassB:
>     def __init__(self):
>         self.createA()
>     def createA(self):
>         self.objA=moduleA.MyClassA()

You do understand that self.objA won't be the same MyClassA instance as 
the one that instanciated this instance of MyClassB, do you ?

>     def execute(self):
>         self.objA.validate(111,'')
>     def display(self,age,address):
>         print 'displaying:',str(age),address

You don't have to call str on age here.

> 
> when i run the code i get a message
> AttributeError: MyClassA instance has no attribute 'objB'

Indeed.

You first create an instance of MyClassA named objA, call createClassB() 
on it which create an instance of MyClassB referenced by objA.objB.

When objA.objB is created, it itself creates another instance of 
MyClassA referenced by objA.objB.objA, which is totally distinct from 
objA...

Then you call objA.callB(),
which itself call objA.objB.execute(),
which in turn call objA.objB.objA.validate(),
which in turn call objA.objB.objA.objB.display().

But at this point, objA.objB.objA (which, I repeat, is *not* objA) has 
no attribute objB since you didn't call objA.objB.objA.createClassB()...

You could have understood this by yourself, either the way I did 
(mentally tracing program execution) or using a couple print statements 
in your code (to effectively trace program execution), or using the 
debugger...

> Do i have to put a placeholder for objB in __init__ of MyClassA ?
> is that why i get this error?someone please tell me how i can solve
> this?  I tried to put self.objB=None but it didn't work..

<ot>
Trying anything that comes to mind instead of trying to understand how 
things work is a well-known antipattern named "programming by accident". 
The best you can hope from this approach is that, for unknown reasons, 
things accidentally seem to work. Until the day where, for still unknown 
reasons, they either stop working, or it appears they never really 
worked at all.

Needless to say, this approach is a pure waste of time.
</ot>

class ClassA(object):
     def __init__(self, age=0, address=''):
         self.age = age
         self.address = address
         self.b= ClassB(self)

     def validate(self,age,address):
         if(age >= 100 or address==''):
             self.age=20;
             self.address="Broadway,NewYork"
         self.b.display(self.age, self.address)

     def call_b(self):
         self.b.execute()

class ClassB(object):
     def __init__(self, a):
         self.a = a
     def execute(self):
         self.a.validate(111,'')
     def display(self, age, address):
         print 'displaying: %s %s' % (age, address)

if __name__ == "__main__":
     objA=ClassA()
     objA.call_b()


Note that this is still uselessly messy and arbitrary 
overcomplificated... Such a ping-pong between two classes is more often 
than not a design smell.

HTH