In this article we want to learn about Python Super() Function , so python super() function is used for accessing the methods and properties of the base class or super class, basically a super function returns a proxy object, or we can say In Python, super() is built-in function that returns temporary object of superclass, allowing access to its methods and attributes. it is commonly used in object-oriented programming to call method in parent or superclass while making sure that all necessary setup and cleanup operations are performed.
super() function is typically used inside subclass to call method defined in its parent class. by using super(), the subclass can inherit the functionality of the parent class while also adding its own behavior.
Benefits of Python Super Function
The benefits of using super() function in Python are:
- Code reusability: super() function allows subclass to inherit and reuse the code from its parent class, avoiding duplication of code and reducing the amount of code that needs to be written.
- Dynamic method resolution: super() enables dynamic method resolution, which means that if the inheritance hierarchy changes, the same super() call can be used to call the updated method in the new parent class.
- Maintains method resolution order: super() function is aware of the method resolution order (MRO) of class, so it can ensure that the correct method is called in the correct order in the inheritance hierarchy.
- Prevents hardcoding class names: Using super() avoids hardcoding the names of parent classes and it makes the code more flexible and easier to maintain.
So we can say that super() function is an important tool for object oriented programming in Python, enabling inheritance, code reuse and dynamic method resolution. it can make code more flexible and easier to maintain and helps to avoid errors that can arise from hardcoding class names or method calls.
Now we want to create an example in Python Super() Function.
|
1 2 3 4 5 6 7 8 9 10 11 |
class Person: def __init__(self): print("This is person base class") class Employee(Person): def __init__(self): print("This is employee derived class ") emp = Employee() |
In the example we have two classes, the first class is Person class and it is our base class, we have our initializer method in this class, also in the initializer method we are just printing some texts. the second class is Employee class and it is a child class of the Person class, and in here also we are going to print something in the console. now if you run this code you will see that it is not calling the base class initializer method, but it is calling the derived class initializer method.
Run the code and this will be the result, even though we are extending from the Person class, but by instantiating the Employee class it is not calling the base class __init__ method.
Now what if we want to call our base class initializer method, for that we are going to use the super function in Python, let’s bring changes to our code and add the super function.
|
1 2 3 4 5 6 7 8 9 10 11 12 |
class Person: def __init__(self): print("This is person base class") class Employee(Person): def __init__(self): super().__init__() print("This is employee derived class ") emp = Employee() |
Learn More
- Python Google Translate API
- How to Convert Text to Speech in Python
- How to Rotate an Image in Python OpenCV
If you run the code this will be the result and you can see that now it is calling our base class method at the first.
Let’s create another example.
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
class Person: def __init__(self, name, age): self.name = name self.age = age class Employee(Person): def __init__(self, name, age, email): super().__init__(name, age) self.email = email emp = Employee("Codeloop", 25, "codeloop@gmail.com") print(emp.name) print(emp.age) print(emp.email) |
In this code, Person is a super (parent) class, while Employee is a derived (child) class. the usage of the super function allows the child class to access the parent class’s init() property. In other words, super() allows you to build classes that easily extend the functionality of previously built classes without implementing their functionality again.
FAQs:
What does super() do in Python?
The super() function in Python is used to call methods and access attributes from the superclass (parent class) inside a subclass (child class). It returns a proxy object that delegates method calls to the parent class, and it allows you to invoke superclass methods without explicitly naming the parent class.
Why is super() used?
super() is used to facilitate method overriding and maintain the integrity of the inheritance hierarchy. It allows subclasses to call methods from the superclass, make code reusability and reducing redundancy. By using super(), you ensure that changes made to superclass methods are automatically reflected in all subclasses.
What is super().__init__ in Python?
In Python, super().__init__ is a way to call the constructor (__init__ method) of the superclass from the subclass. This is commonly used to initialize attributes inherited from the superclass before adding additional attributes specific to the subclass. It ensures that the initialization logic defined in the superclass is executed when creating instances of the subclass.
What is the super function in Python with arguments?
The super() function in Python can take two arguments: the subclass and an object instance. This form of super() is often used in multiple inheritance scenarios where you want to explicitly specify the superclass and the object instance to delegate method calls to. The syntax is like this:
|
1 |
super(Subclass, instance) |
Subscribe and Get Free Video Courses & Articles in your Email