When learning Object-Oriented Programming (OOP) in Python, one of the fundamental concepts to understand is the constructor. The constructor is a special method that is executed when an object is created from a class. In this post, we will dive into Python constructors, default constructors in Python, and constructor overriding in Python.
What is a Constructor in Python?
In Python, a constructor is a special method that initializes an object of a class. It’s the method that gets called when you create a new instance of a class. The name of this method is always __init__
. The double underscores before and after the name signify that it’s a special method.
Syntax:
class ClassName:
def __init__(self, [parameters]):
# code to initialize the object
Here’s an example:
class Car:
def __init__(self, brand, model):
self.brand = brand
self.model = model
In this example, we have a simple Car
class with a constructor that takes two parameters: brand
and model
.
Creating a new instance of the Car
class:
my_car = Car("Toyota", "Corolla")
print(my_car.brand)
print(my_car.model)
You can check the output below:
Default Constructor in Python
A default constructor is a constructor that doesn’t take any parameters (except for self
, which refers to the object itself). If you don’t define a constructor in your class, Python will automatically provide a default constructor that doesn’t do anything.
Here’s an example:
class Animal:
pass
my_animal = Animal()
In this example, the Animal
class doesn’t define a constructor, so Python provides a default one. You can create an instance of Animal
without passing any parameters.
Parameterized Constructor
If you want your constructor to accept parameters to initialize the object’s attributes, you can define a constructor with additional parameters.
Here’s an example:
class Circle:
def __init__(self, radius):
self.radius = radius
def area(self):
return 3.14 * self.radius * self.radius
my_circle = Circle(5)
print(my_circle.area()) # Output: 78.5
In the above example, the Circle
class has a constructor that takes a parameter radius
, and a method area
to calculate the area of the circle.
Constructor Overriding in Python
In OOP, a subclass can provide a specific implementation of a method that is already defined in its superclass. This is known as method overriding. Constructor overriding is when a subclass provides its own implementation of the constructor.
Let’s look at an example:
class Person:
def __init__(self, name):
self.name = name
class Employee(Person):
def __init__(self, name, employee_id):
super().__init__(name)
self.employee_id = employee_id
person = Person("Alice")
employee = Employee("Bob", 123)
print(person.name)
print(employee.name)
print(employee.employee_id)
In this example, the Employee
class is a subclass of Person
. The Employee
class overrides the constructor of the Person
class to accept an additional parameter employee_id
. The super()
function is used to call the constructor of the superclass (Person
).
You can see the output in the below screenshot.
Conclusion
Understanding constructors is essential when working with classes and objects in Python. In this post, we explored the basics of constructors, including the default constructor provided by Python, how to define a parameterized constructor, and how to override constructors in subclasses.
You may like the following Python tutorials:
I am Bijay Kumar, a Microsoft MVP in SharePoint. Apart from SharePoint, I started working on Python, Machine learning, and artificial intelligence for the last 5 years. During this time I got expertise in various Python libraries also like Tkinter, Pandas, NumPy, Turtle, Django, Matplotlib, Tensorflow, Scipy, Scikit-Learn, etc… for various clients in the United States, Canada, the United Kingdom, Australia, New Zealand, etc. Check out my profile.