{"id":5078,"date":"2020-04-24T15:40:11","date_gmt":"2020-04-24T15:40:11","guid":{"rendered":"https:\/\/www.askpython.com\/?p=5078"},"modified":"2022-08-06T13:28:37","modified_gmt":"2022-08-06T13:28:37","slug":"super-method-in-python","status":"publish","type":"post","link":"https:\/\/www.askpython.com\/python\/built-in-methods\/super-method-in-python","title":{"rendered":"Understanding the super() Method in Python"},"content":{"rendered":"\n

Introduction<\/h2>\n\n\n\n

Today in this tutorial, we are going to discuss the super() method in Python<\/strong>. <\/p>\n\n\n\n

Before diving right into the topic, we highly recommend going through the tutorial on Python Inheritance<\/a>.<\/p>\n\n\n\n

Once you know about inheritance in Python, we can get started.<\/p>\n\n\n\n

The super() Method in Python<\/h2>\n\n\n\n

The super<\/code> method returns a proxy object that delegates method calls to a parent or sibling class of type<\/strong>. This is useful for accessing inherited methods that have been overridden in a class. <\/p>\n\n\n\n

Or simply, it is used to call the constructor, i.e. the __init__()<\/code> method of the superclass<\/strong>.<\/p>\n\n\n\n

Syntax<\/strong> for using super in Python is given below.<\/p>\n\n\n

\nsuper([type[, object-or-type]])\n<\/pre><\/div>\n\n\n
In Python 3.x<\/strong> versions, we can use super without passing the above two parameters. Look at the code snippet below.<\/p>\n\n\n
\nclass C(B):\n    def method(self, arg):\n        super().method(arg)\n<\/pre><\/div>\n\n\n
Here, C<\/code> is the derived class, B<\/code> is the base class, method is a user defined function with argument arg<\/code>. <\/p>\n\n\n\n
As you can see, the line super().method(arg)<\/code> is actually equivalent to super( C, self).method(arg)<\/code> in Python 3.x<\/strong>. This is not allowed in Python 2.x<\/strong>. Hence, using super there is a bit tricky.<\/p>\n\n\n\n
Using super()<\/h2>\n\n\n\n
Consider the below given example.<\/p>\n\n\n
\nclass Demo:\n    a = 0\n    b = 0\n    c = 0\n    def __init__(self,A,B,C):\n        self.a = A\n        self.b = B\n        self.c = C\n    def display(self):\n        print(self.a, self.b, self.c)\n\nclass Newdemo(Demo):\n    d = 0\n    def __init__(self,A,B,C,D):\n        self.a = A\n        self.b = B\n        self.c = C\n        self.d = D\n\n    def display(self):\n        print(self.a, self.b, self.c,self.d)\n\nB1 = Demo(100,200,300)\nprint("Contents of Base Class:")\nB1.display()\nD1 = Newdemo(10,20,30,40)\nprint("Contents of Derived Class:")\nD1.display()\n<\/pre><\/div>\n\n\n
Output<\/strong>:<\/p>\n\n\n\n
\"Output1\"
Output<\/figcaption><\/figure><\/div>\n\n\n\n
In the above example, the classes derived from the base class Demo<\/code> were not implemented efficiently or robustly.<\/p>\n\n\n\n
The derived class Newdemo<\/code> explicitly initializes the value of A, B, and C fields of the base class. The same duplication of code is found while initialization of the same fields in the base class, Demo<\/code> too. <\/p>\n\n\n\n
This process is inefficient. This implies that a subclass<\/strong> must be granted access to the members of a superclass<\/strong>.<\/p>\n\n\n\n
Therefore, whenever a subclass needs to refer to its immediate super class, super<\/code> comes into the picture.<\/p>\n\n\n\n
Super() to Call Super Class Constructor<\/h3>\n\n\n\n
Now let us apply the super()<\/code> method for the above example.<\/p>\n\n\n
\nclass Demo:\n    a = 0\n    b = 0\n    c = 0\n    def __init__(self,A,B,C):\n        self.a = A\n        self.b = B\n        self.c = C\n    def display(self):\n        print(self.a, self.b, self.c)\n\nclass Newdemo(Demo):\n    d = 0\n    def __init__(self,A,B,C,D):\n        self.d = D\n        super().__init__(A,B,C) #super to call super Class\n        #The __init__() Method\n\n    def display(self):\n        print(self.a, self.b, self.c,self.d)\n\nB1 = Demo(12,34,56)\nprint("Contents of Base Class:")\nB1.display()\nD1 = Newdemo(11,22,33,44)\nprint("Contents of Derived Class:")\nD1.display()\n<\/pre><\/div>\n\n\n
Output<\/strong>:<\/p>\n\n\n\n
\"Output\"
Output<\/figcaption><\/figure><\/div>\n\n\n\n
Here, the derived class Newdemo<\/code> calls the super()<\/code> with arguments a<\/strong>, b<\/strong>, and c<\/strong>. This causes the constructor __init__<\/code> of the base class, i.e. Demo<\/code> to be called. This initialises the values of a<\/strong>, b<\/strong>, and c<\/strong>. Hence, the Newdemo<\/code> class no longer initialises the values itself.<\/p>\n\n\n\n
Using super in Python 2.x<\/h2>\n\n\n\n
The syntax<\/strong> to call a super<\/code> class constructor in Python 2.x<\/strong> is given below,<\/p>\n\n\n
\nsuper(Derived_Class_Name, self).__init__(Parameters_of_Super_Class_Constructor)\n<\/pre><\/div>\n\n\n
Hence we need to make some minor changes to the above example if we want to use it in Python 2<\/strong>.<\/p>\n\n\n\n
Firstly, we need to put object<\/code> in the base class as shown below.<\/p>\n\n\n
\nclass Demo(object):\n...#other statements\n<\/pre><\/div>\n\n\n
And secondly, pass Newdemo<\/code> and self<\/code> at the site of super class call. Like this.<\/p>\n\n\n
\nsuper(Newdemo,self).__init__(A,B,C) #super to call super Class\n...        #The __init__() Method\n<\/pre><\/div>\n\n\n
Why we need super()<\/h2>\n\n\n\n
In the case of single inheritance<\/strong> with a parent and offspring class, the super<\/code> function is used to implicitly refer to the parent class without naming it explicitly. This makes the code more efficient, maintainable and robust in nature.<\/p>\n\n\n\n
Nextly, for a multi-level inheritance<\/strong>, the super<\/code> method can be used to refer to the immediate superclass implicitly. This again makes the code easier to understand and highly maintainable.<\/p>\n\n\n\n
Conclusion<\/h2>\n\n\n\n
So in this tutorial we understood the concept of super() method in Python<\/strong>, its use and need.<\/p>\n\n\n\n
For any further questions, feel free to comment below.<\/p>\n\n\n\n
References<\/h2>\n\n\n\n