CODEWITHSUNDEEP
pythonpython-3.xoop
Suga Raj
Suga Raj

Reputation: 551

What is the difference between calling a method from parent class using super() and using self?

class Car:
    def __init__(self, car_name, manufacturer, cost):
        self.__car_name=car_name
        self.__manufacturer=manufacturer
        self.__cost=cost

    def display_car_details(self):
        print(self.__car_name, self.__manufacturer, self.__cost)

class Super_Car(Car):
    def __init__(self, car_name, manufacturer, cost, 
                 top_speed, material_used, engine_type):
        super().__init__(car_name, manufacturer, cost)
        self.__top_speed=top_speed
        self.__material_used=material_used
        self.__engine_type=engine_type

    def display_super_car_details(self):
        self.display_car_details()  # this?
        super().display_car_details()  # or that?
        print(self.__top_speed, self.__material_used, 
              self.__engine_type)

Please tell me the difference between calling display_car_details() by using self.… and calling by super().…. The method which calls the above function is in Super_car class with name display_super_car_details().

Upvotes: 2

Views: 105

Answers (1)

Jonas Schäfer
Jonas Schäfer

Reputation: 20738

In your specific case, there is no difference. If the methods had the same name, you would not be calling the parent class using self.…, but your own method again, creating infinite recursion.

With super(), the call is always going to the method in the parent class in Method Resolution Order, thus preventing the infinite recursion. More details on super() itself can also be found in the official documentation.

Generally, you only need super() if you really need the inherited method, such as when re-implementing that exact method.

For example, running this code will lead to RecursionError, due to maximum recursion depth exceeded. The reason is that Bar.method1() calls itself over and over, because we are using self.… instead of super().….

class Foo:
    def method1(self):
        print("I just want to be called")

class Bar(Foo):
    def method1(self):
        self.method1()  # oops

b = Bar()
b.method1()

This on the other hand has the intended effect:

class Foo:
    def method1(self):
        print("I just want to be called")

class Bar(Foo):
    def method1(self):
        super().method1()  # sweet

b = Bar()
b.method1()

Again, in your specific example it does not matter, because the other method (display_car_details) is only defined in the parent class, so it is unambiguous which method to call. If you had overridden display_car_details with something different, the use of super() and self would again yield different results:

class Bar(Foo):
   def method1(self):
       print("You are not supposed to call this")
   def method2(self):
       super().method1()
   def method3(self):
       self.method1()

Observe the difference in the interactive interpreter:

>>> b = Bar()
>>> b.method1()
You are not supposed to call this
>>> b.method2()
I just want to be called
>>> b.method3()
You are not supposed to call this

Upvotes: 2

Related Questions