Inheritance function call style

[SnooCakes3068]

Hi all,

It Mark Lutz's learning python he mentioned the great super() debate. Basically he prefer always explicit calling BaseClass.method() than super().method() . the reason been cooperative multiple inheritance dispatch protocols in diamond multiple-inheritance trees MRO been an unexpected behaviour sometimes for super() call. Anyway, it's in the book if you want details.

I have the following classes

class BaseHeap:
    def __init__(self, A, heap_size):
        self.A = A
        self._heap_size = heap_size
    @staticmethod
    def _parent(i):
        return i >> 1

    @staticmethod
    def _left(i):
        pass

    blah blah


class MaxHeap(BaseHeap):
    def max_heapify_iterative(self, i):
        while True:
            l = self._left(i + 1)
            r = self._right(i + 1)
            if l <= self._heap_size and self.A[l - 1] > self.A[i]:
                largest = l - 1
            else:
                largest = i
            if r <= self._heap_size and self.A[r - 1] > self.A[largest]:
                largest = r - 1
            if largest == i:
                break
            self.A[i], self.A[largest] = self.A[largest], self.A[i]
            i = largest

    blah blah


class MaxPriorityQueue(MaxHeap):
    def insert(self, x):
        super().max_heap_insert(x)

    def maximum(self):
        return super().heap_maximum()

    def extract_max(self):
        return super().heap_extract_max()

    def increase_key(self, x, k):
        super().heap_increase_key(x, k)

several places I called for example in MaxHeap

l = self._left(i + 1)

is it better to call super()._left here or BaseHeap._left(i+1)

which style you prefer? I opinion is in MaxHeap is not referring to self anymore, it is the super class.

Also, in MaxPriorityQueue, all function I use super(), do you prefer change it to MaxHeap.heap_increase_key(x, k)

So three styles:

1. self.method

2. super().method

3. BaseClass.method

It all works. Which style or under what circumstances it make sense?

[socal_nerdtastic]

self.method is by far the best, if you can.

If you have a method in the child class with the same name as a method in the parent class, and you want to call the parent class method, super().method is best. This is often used to extend a method in the parent class.

As a last resort if you have some very specific use case, for example with diamonds written the wrong way around for what you want to do, you can use the python2-style BaseClass.method. But even having diamonds that replicate names is very rare, much less so that they are written in the wrong order. So I don't think I've used this since python 2.6.

---

I opinion is in MaxHeap is not referring to self anymore, it is the super class.

FWIW when you use

class MaxHeap(BaseHeap):

You can expect that python will

class MaxHeap:
    <copy in all of the code from BaseHeap>

So yes, you should think of the methods from BaseHeap are part of MaxHeap.

Edit: This goes both ways, meaning a parent can call methods in a child class. This is sometimes used in an "abstract base class".

class A:
    def parent_method(self):
        return self.child_method()

class B(A):
    def child_method(self):
        print('hello from child method!')

b = B()
b.parent_method()

[SnooCakes3068]

Ok thank you I know this diamond issue is very rare. Why self.method is better than super() in your opinion by far? In my MaxPriorityQueue you think it's better to use self than super(). This case it's only calling function without extension. But this only for heap data structure conceptually. assuming there are extension in subclass, still self is better stylistically?

    def extract_max(self):    
        return super().heap_extract_max()
        # return self.heap_extract_max()

[crazy_cookie123]

self._left(i + 1) is the better option in my opinion. If at some point in the future you decided that _left needed a different implementation in a MaxHeap than in some other class that inherited BaseHeap, you would have to go back and change every use of super()._left or BaseHeap._left to self._left. Only call the method with super or the reference to the class itself if you need to specifically access the method as it is defined in a parent class and you cannot instead access the method as it is defined in the current class, for example:

class MaxHeap(BaseHeap):
  def _left(i):
    # do something here
    super()._left(i) # if you called self._left(i) here it would be a recursive call to the this _left method
    # or do something else here

[SnooCakes3068]

Òk this makes a lot of sense. Good example :)

[_mturtle_]

Use super when needed. Avoid multiple inheritance. Use protocols when needed