What Are Constructors In Python?

Photo of author

In Python, we define constructors using the __init__ method, which is the program calls automatically when we create a new class instance. Constructors are a crucial aspect of object-oriented programming, as they allow developers to set the initial state of an object and perform any necessary setup tasks before the program uses the object.

Constructors in Python

Follow this article to know more on working of constructors in Python.

See Also: What Are The Key Features Of Python


How Constructors Work In Python

To understand how constructors work in Python, let’s first consider the basic syntax of a class definition in Python.

Constructors in Python

Here is an example of a simple class definition in Python:

Class MyClass:

    # Class attribute

    attribute = “class attribute”

    # Constructor

    def __init__(self):

        self.attribute = “instance attribute”

    # Instance method

    def my_method(self):

        return self.attribute

In this example, MyClass is a class with a single class attribute called an attribute, a constructor defined using the __init__ method, and a single instance method called my_method.

The __init__ Method

The __init__ method is called the constructor because it is responsible for initializing the object when you create it. All instance methods in Python have this self-argument, allowing them to access and modify the object’s instance data.


The __init__ method can accept additional arguments beyond self, which you can use to initialize the object with specific data. For example, the following __init__ method accepts two arguments, name and age, and uses them to initialize the instance data of the object:

class Person:

    def __init__(self, name, age):

        self.name = name

        self.age = age

To create a new instance of the Person class, you would call the class name as if it were a function, passing in any necessary arguments:

person = Person(“John”, 30)

This will create a new Person object with the name “John” and age 30. The __init__ method will be called automatically to initialize the object, setting the name and age attributes of the object to the values passed in as arguments.

It’s important to note that the program calls for __init__ method automatically when you create a new class instance, but not when the class defines itself. This means that any code you write inside the __init__ method will only be executed when an instance of the class is created, not when the class is defined.

Use Of Constructors

Use of Constructors

One common use of constructors is to perform setup tasks necessary before the program can use the object. For example, a constructor might open a file or establish a database connection that the object needs.

For example, the following __init__ method initializes the name and age attributes of the Person object:

class Person:

    def __init__(self, name, age):

        self.name = name

        self.age = age

In this case, the name and age attributes of the Person object are set to the values passed in as arguments when you create the object. This allows you to create objects with different data by calling the constructor with different arguments.

It’s also possible to define default values for the arguments of the __init__ method in case the caller does not provide them. For example, the following __init__ method sets a default value of “Unknown” for the name argument:

class Person:

    def __init__(self, name=”Unknown”, age):

        self.name = name

        self.age = age

In this case, if you create a Person object without providing a value for the name argument, it will set to the default value of “Unknown”.

See Also: What Are The Use Cases Of Python?

Feature Of Constructors

Another critical aspect of constructors is inheritance. In Python, a class can inherit properties and methods from another class known as the base class. When constructors derive a class from a base class, it can override or extend the behavior of the base class by defining new methods or attributes or modifying the existing ones.

Feature of Constructors

For example, consider the following class hierarchy:

class Animal:

    def __init__(self, species):

        self.species = species

class Cat(Animal):

    def __init__(self, name, breed):


        self.name = name

        self.breed = breed

In this example, the Cat class is derived from the Animal class, which means it inherits the __init__ method and the species attribute from the Animal class. However, the Cat class also defines its __init__ method and adds two additional attributes, name and breed.

The Cat class uses the super() function to call the __init__ method of the base class, which initializes the species attribute of the object. The Cat class then initializes the name and breed attributes of the object using the arguments passed in by the caller.

This allows you to create a Cat object by calling the Cat constructor with the name and breed arguments while still inheriting the behavior of the Animal class.

See Also: How To Set Environment Variables In Python?


Constructors are an essential aspect of object-oriented programming in Python. They allow you to initialize objects and perform necessary setup tasks when you create them. Constructors can accept arguments to customize an object’s data. You can use them in conjunction with inheritance to extend the behavior of a base class. Understanding how to use constructors effectively is crucial for any Python developer working with object-oriented code.

See Also: How To Fix SyntaxError Unexpected EOF While Parsing?

Leave a Comment