Python: Exceeding max recursion depth while calling superclass method from subclass

Question

I've got an inheritance chain of three classes: Baz inherits from Bar inherits from Foo. I'd like to define a method in the Foo class that, when called in a subclass, returns the output of its parent class appended with stuff of its own. This is the desired output:

>>> foo = Foo()
>>> bar = Bar()
>>> baz = Baz()
>>> print foo.get_defining_fields()
['in Foo']
>>> print bar.get_defining_fields()
['in Foo', 'in Bar']
>>> print baz.get_defining_fields()
['in Foo', 'in Bar', 'in Baz']

The problem is, I'm misunderstanding something about the use of super() in superclass methods that are called by subclasses, or some other subclassing detail. This bit works fine:

>>> print foo.get_defining_fields()
['in Foo']

But bar.get_defining_fields() produces an infinite loop, running itself until a RuntimeError is raised instead of calling out to foo.get_defining_fields and stopping there like I want it to.

Here's the code.

class Foo(object):
    def _defining_fields(self):
        return ['in Foo']

    def get_defining_fields(self):
        if self.__class__ == Foo:
            # Top of the chain, don't call super()
            return self._defining_fields()
        return super(self.__class__, self).get_defining_fields() + self._defining_fields()

class Bar(Foo):
    def _defining_fields(self):
        return ['in Bar']

class Baz(Bar):
    def _defining_fields(self):
        return ['in Baz']

So get_defining_fields is defined in the superclass, and the super() call within it uses self.__class__ in an attempt to pass the correct subclass name to the call in each subclass. When called in Bar, it resolves to super(Bar, self).get_defining_fields() so that the list returned by foo.get_defining_fields() would be prepended to the one returned by far.get_defining_fields().

Probably a simple mistake if you properly understand Python's inheritance mechanics and the inner workings of super(), but since I obviously don't, I'd appreciate it if someone could point me to the proper way of doing this.

EDIT: as per Daniel Roseman's answer, I tried replacing the super() call with this form: return super(Foo, self).get_defining_fields() + self._defining_fields()

Now the infinite recursion no longer occurs, but I get a different error when calling bar.get_defining_fields():

AttributeError: 'super' object has no attribute 'get_defining_fields'

Something else is still amiss.

EDIT: yep, finally figured out what I was missing here. Marked Daniel's updated answer as the accepted one.

@Charles Beattie: This is true for Python 3 where all classes are new-style classes, but not encouraged in Python 2. — jena
– jena, Commented Jul 3, 2011 at 11:16
I deleted my comment but I was asking before why he was deriving from object. Hence jena's reply. — Charles Beattie
– Charles Beattie, Commented Jul 3, 2011 at 14:46

Daniel Roseman · Accepted Answer · 2011-07-03 12:17:25Z

8

The problem is here:

 return super(self.__class__, self)...

self.__class__ always refers to the current concrete class. So in Bar, it refers to Bar, and in Baz, it refers to Baz. So, Bar calls the superclass's method, but the self.__class__ still refers to Bar, not Foo. So you will get an endless recursion.

That's why you must always refer to the class specifically in super. Like this:

return super(Foo, self)...

Edit Right, because only the top class defines get_defining_fields.

You're going about this the wrong way, really. This isn't a job for super at all. I think you might get better results iterating through self.__class__.__mro__, which is the way to access the method resolution order of the superclasses:

class Foo(object):
    def _defining_fields(self):
        return ['in Foo']

    def get_defining_fields(self):
        fields = []
        for cls in self.__class__.__mro__:
            if hasattr(cls, '_defining_fields'):
                fields.append(cls._defining_fields(self))
        return fields

¬

edited Jul 3, 2011 at 12:17

answered Jul 3, 2011 at 11:25

Daniel Roseman

602k68 gold badges910 silver badges923 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

JK Laiho Over a year ago

That solved the recursion, but brought about an AttributeError instead. I edited the question accordingly.

JK Laiho Over a year ago

Yeah, my thinking was muddled, I was under the impression that Bar would inherit get_defining_fields as-is and running it from under Bar would make it "Bar's method" as far as the super() call was concerned.

Collectives™ on Stack Overflow

Python: Exceeding max recursion depth while calling superclass method from subclass

1 Answer 1

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related