When calling super() in a derived class, can I pass in self.__class__? [duplicate]

I've recently discovered (via StackOverflow) that to call a method in a base class I should call:

super([[derived class]], self).[[base class method]]()

That's fine, it works. However, I find myself often copying and pasting between classes when I make a change and frequently I forget to fix the derived class argument to the super() function.

I'd like to avoid having to remember to change the derived class argument. Can I instead just use self.__class__ as the first argument of the super() function?

It seems to work but are there good reasons why I shouldn't do this?

Solution 1:

No you cannot. The super() call needs to know what class the method is part of, to search the base classes for an overridden method.

If you pass in self.__class__ (or better still, type(self)) then super() is given the wrong starting point to search for methods, and will end up calling its own method again.

See it as a pointer in the list of classes that form the Method Resolution Order sequence. If you pass in type(self) then the pointer will refer to any subclasses instead of the original starting point.

The following code leads to an infinite recursion error:

class Base(object):
    def method(self):
        print 'original'

class Derived(Base):
    def method(self):
        print 'derived'
        super(type(self), self).method()

class Subclass(Derived):
    def method(self):
        print 'subclass of derived'
        super(Subclass, self).method()

Demo:

>>> Subclass().method()
subclass of derived
derived
derived
derived

<... *many* lines removed ...>

  File "<stdin>", line 4, in method
  File "<stdin>", line 4, in method
  File "<stdin>", line 4, in method
RuntimeError: maximum recursion depth exceeded while calling a Python object

because type(self) is Subclass, not Derived, in Derived.method().

In the example, the MRO for Subclass is [Subclass, Derived, Base], and super() needs to know where to start searching for any overridden methods. By using type(self) you tell it to start at Subclass, so it'll find Derived.method() next, which is where we started.

Solution 2:

self.__class__ might not be a subclass, but rather a grandchild-or-younger class, leading to a stack-breaking loop.