[General lang] how to call a parent
johnf at jfcomputer.com
Mon Jun 16 15:50:45 CEST 2003
Thank you for the help. I think I understand. Now that I have the
required tools I will start a small project. Thanks again.
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
> / \
> / \
> B C
> \ /
> \ /
> 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.
More information about the Python-list