[General lang] how to call a parent

[JOHN FABIANI]

Thank you for the help.  I think I understand. Now that I have the
required tools I will start a small project.  Thanks again.
John
On Sun, 2003-06-15 at 19:19, Jeff Epler wrote:
> On Sun, Jun 15, 2003 at 11:01:46PM +0000, John Fabiani wrote:
> > I'm just starting to use python and playing with the tools and the language. 
> > After building a few small windows (via BOA) I realized that I did not know
> > how to create a class that allowed reuse in a general way.  I was testing
> > how classes are used.  I was able create properties, call the __init__ of
> > the parent class .etc  But then I realized I did not have a way to call a
> > parent of control - such as a container.  Also I was not aware of "super". 
> > I'm guessing that will help.  Still learning!!!!!!!!!!!!
> > John
> 
> Yeah.  I didn't get in your first message that you were asking about the
> inheritance tree -- I thought you were talking about parents in terms of a
> tree-representation of an HTML document, for instance.
> 
> You must use super() if you expect the inheritance graph to be a DAG instead
> of a tree (i.e., there's a "diamond shape" hiding somewhere).  For
> instance, if you have
>                A
>               / \
>              /   \
>             B     C
>              \   /
>               \ /
>                D
> 	class A(object): pass # super works only for "new-style objects"
> 	class B(A): pass
> 	class C(A): pass
> 	class D(B,C): pass
> then follwing the rule (for cooperative methods) "each subclass method calls
> the method defined on each of its base classes" will get you into trouble:
> D.f calls both B and C, which in turn gives *two* calls to A.f (not the one
> call you'd expect).  Super defines a strange-seeming order where each subclass
> method calls *one* method defined on a base class, but the call may not be
> to an ancestor class of the class making the call via super.  Confused yet?
> 
> Now, if you don't want to accomodate diamond-shape inheritance, then
> there's a simpler way.  Just call the method by referencing the class
> attribute, and explicitly name self as the first argument:
> >>> class A:
> ...     def f(self, arg): print "A.f(%r,%r)" % (self, arg)
> ... 
> >>> class B(A):
> ...	def f(self, arg):
> ...         print "B.f(%r,%r)" % (self, arg)
> ...         A.f(self, "spam") # call parent method
> ...
> >>> o = B()
> >>> o.f(37)
> B.f(<__main__.B instance at 0x81d548c>,37)
> A.f(<__main__.B instance at 0x81d548c>,'spam')
> 
> Wondering about the diamond and super?  Write the code yourself.  The
> cooperative call looks like this:
>         super(X, self).f(arg)
> where X is the name of the class in which you're defining the method.
> Remember, super only works when you make your classes new-style by deriving
> from object.
> 
> Jeff
>