Python super()
How Inheritance is working without super
Python3
# code class Person: # Constructor def __init__( self , name, id ): self .name = name self . id = id # To check if this person is an employee def Display( self ): print ( self .name, self . id ) class Emp(Person): def __init__( self , name, id ): self .name_ = name def Print ( self ): print ( "Emp class called" ) Emp_details = Emp( "Mayank" , 103 ) # calling parent class function Emp_details.name_, Emp_details.name |
Output:
--------------------------------------------------------------------------- AttributeError Traceback (most recent call last) <ipython-input-12-46ffda859ba6> in <module> 24 25 # calling parent class function ---> 26 Emp_details.name_, Emp_details.name AttributeError: 'Emp' object has no attribute 'name'
In above code Emp class is inherits the Person class
- Both class has the __init__ constructor
- trying to call name & name_ from other class
- But we will encounter the above error
With super implementation in inherent we can solve the problem. example can found below
The Python super() function returns objects represented in the parent’s class and is very useful in multiple and multilevel inheritances to find which class the child class is extending first.
Syntax of super() in Python
Syntax: super()
Return : Return a proxy object which represents the parent’s class.
Example of super() function in Python
Python3
class Emp(): def __init__( self , id , name, Add): self . id = id self .name = name self .Add = Add # Class freelancer inherits EMP class Freelance(Emp): def __init__( self , id , name, Add, Emails): super ().__init__( id , name, Add) self .Emails = Emails Emp_1 = Freelance( 103 , "Suraj kr gupta" , "Noida" , "KKK@gmails" ) print ( 'The ID is:' , Emp_1. id ) print ( 'The Name is:' , Emp_1.name) print ( 'The Address is:' , Emp_1.Add) print ( 'The Emails is:' , Emp_1.Emails) |
Output:
The ID is: 103 The Name is: Suraj kr gupta The Address is: Noida The Emails is: KKK@gmails
Solving the first problem using super
Python3
# code # A Python program to demonstrate inheritance class Person: # Constructor def __init__( self , name, id ): self .name = name self . id = id # To check if this person is an employee def Display( self ): print ( self .name, self . id ) class Emp(Person): def __init__( self , name, id ): self .name_ = name super ().__init__(name, id ) def Print ( self ): print ( "Emp class called" ) Emp_details = Emp( "Mayank" , 103 ) # calling parent class function print (Emp_details.name_, Emp_details.name) |
output
Mayank Mayank
Understanding Python super() with __init__() methods
Python has a reserved method called “__init__.” In Object-Oriented Programming, it is referred to as a constructor. When this method is called it allows the class to initialize the attributes of the class. In an inherited subclass, a parent class can be referred with the use of the super() function. The super function returns a temporary object of the superclass that allows access to all of its methods to its child class.
Note: For more information, refer to Inheritance in Python
The benefits of using a super() function are:
- Need not remember or specify the parent class name to access its methods. This function can be used both in single and multiple inheritances.
- This implements modularity (isolating changes) and code reusability as there is no need to rewrite the entire function.
- Super function in Python is called dynamically because Python is a dynamic language, unlike other languages.
Super function in single inheritance
Let’s take the example of animals. Dogs, cats, and cows are part of animals. They also share common characteristics like –
- They are mammals.
- They have a tail and four legs.
- They are domestic animals.
So, the classes dogs, cats, and horses are a subclass of animal class. This is an example of single inheritance because many subclasses is inherited from a single parent class.
Python3
# Python program to demonstrate # super function class Animals: # Initializing constructor def __init__( self ): self .legs = 4 self .domestic = True self .tail = True self .mammals = True def isMammal( self ): if self .mammals: print ( "It is a mammal." ) def isDomestic( self ): if self .domestic: print ( "It is a domestic animal." ) class Dogs(Animals): def __init__( self ): super ().__init__() def isMammal( self ): super ().isMammal() class Horses(Animals): def __init__( self ): super ().__init__() def hasTailandLegs( self ): if self .tail and self .legs = = 4 : print ( "Has legs and tail" ) # Driver code Tom = Dogs() Tom.isMammal() Bruno = Horses() Bruno.hasTailandLegs() |
Output:
It is a mammal. Has legs and tail
Super function in multiple inheritances
Let’s take another example of a super function, Suppose a class canfly and canswim inherit from a mammal class and these classes are inherited by the animal class. So the animal class inherits from the multiple base classes. Let’s see the use of Python super with arguments in this case
Python3
class Mammal(): def __init__( self , name): print (name, "Is a mammal" ) class canFly(Mammal): def __init__( self , canFly_name): print (canFly_name, "cannot fly" ) # Calling Parent class # Constructor super ().__init__(canFly_name) class canSwim(Mammal): def __init__( self , canSwim_name): print (canSwim_name, "cannot swim" ) super ().__init__(canSwim_name) class Animal(canFly, canSwim): def __init__( self , name): super ().__init__(name) # Driver Code Carol = Animal( "Dog" ) |
Output:
The class Animal inherits from two-parent classes – canFly and canSwim. So, the subclass instance Carol can access both of the parent class constructors.
Dog cannot fly Dog cannot swim Dog Is a mammal
MRO in Multiple Inheritance
Python3
class A: def age( self ): print ( "Age is 21" ) class B: def age( self ): print ( "Age is 23" ) class C(A, B): def age( self ): super (C, self ).age() c = C() print (C.__mro__) print (C.mro()) |
Output:
(<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>) [<class '__main__.C'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
Multi-Level inheritance
Let’s take another example of a super function, suppose a class canSwim is inherited by canFly, canFly from mammal class. So the mammal class inherits from the Multi-Level inheritance. Let’s see the use of Python super with arguments in this case
Python3
class Mammal(): def __init__( self , name): print (name, "Is a mammal" ) class canFly(Mammal): def __init__( self , canFly_name): print (canFly_name, "cannot fly" ) # Calling Parent class # Constructor super ().__init__(canFly_name) class canSwim(canFly): def __init__( self , canSwim_name): print (canSwim_name, "cannot swim" ) super ().__init__(canSwim_name) class Animal(canSwim): def __init__( self , name): # Calling the constructor # of both the parent # class in the order of # their inheritance super ().__init__(name) # Driver Code Carol = Animal( "Dog" ) |
Output:
Dog cannot swim Dog cannot fly Dog Is a mammal
Please Login to comment...