Learning Python- Intermediate course: Day 39, OOP-Constructor init

Today let us check out class constructors in Python

Constructors in Python

Constructors are class methods which are used to set the class parameters a the time of instantiation. These methods are run automatically when the class is instantiated.

The task of constructors is to initialize(assign values) to the data members of the class when an object of class is created. A constructor can optionally accept arguments as well, just like a regular function.

Syntax

The constructor is created by the __init__ keyword.

class sample:
   def  __init__(self):
        print("Class instantiated")

mysample=sample()

Class instantiated

Forgetting to write the self keyword will geneate error

class sample:
   def  __init__():
        print("Class instantiated")

mysample=sample()

Traceback (most recent call last):
  File "main.py", line 5, in <module>
    mysample=sample()
TypeError: __init__() takes 0 positional arguments but 1 was given

The __init__ method runs once class is instantiated.
It can be called from outside the class too.

class sample:
   def  __init__(self):
        print("Class instantiated")

mysample=sample()
mysample.__init__()

Class instantiated
Class instantiated

Moreover, it can be called by other methods inside the class.
Here is example.

class sample:
   def  __init__(self):
        print("Class instantiated")
   def fun(self):
       self.__init__()
       print("inside a function")
mysample=sample()
mysample.fun()

Class instantiated
Class instantiated
inside a function

Every class has a constructor

But yesterday, when we created a class, we did not use any constructors right? Then is the above statement false?
No. When we do not specify a constructor in a class, a default constructor is generated automatically. This is called the default constructor. When we write a constructor by our own, the default constructor is not generated.

Remember this When you create a class without a constructor, Python automatically creates a default constructor for you that doesn't do anything. Every class must have a constructor, even if it simply relies on the default constructor.

Destructors in Python.

The users call Destructor for destroying the object. In Python, developers might not need destructors as much it is needed in the C++ language. This is because Python has a garbage collector whose function is handling memory management automatically. The __del__() function is used as the destructor function in Python. The user can call the __del__() function when all the references of the object have been deleted, and it becomes garbage collected.

The __del__ is pretty much similar to __init__ More about it here

Parametrized constructors

We can pass parameters to the constructors which set the values of the class 'variables'

Let us see a modification of yesterday's program now using the __init__ constructor.

class sample:
   rate=3
   def  __init__(self,amount):
        self.amount=amount
   def calculate_tax(self):
       print(self.rate*self.amount*0.01)
mysample=sample(200)
mysample.calculate_tax()

6.0

Multiple constructors.

Python does not support explicit multiple constructors, yet there are some ways using which the multiple constructors can be achieved. If multiple __init__ methods are written for the same class, then the latest one overwrites all the previous constructors

class sample:
   rate=3
   def  __init__(self,amount):
        self.amount=amount
   def __init__(self,amount,rate):
       self.amount=amount
       self.rate=rate
   def calculate_tax(self):
       print(self.rate*self.amount*0.01)
mysample=sample(200)
mysample.calculate_tax()

Traceback (most recent call last):
  File "main.py", line 13, in <module>
    mysample=sample(200)
TypeError: __init__() missing 1 required positional argument: 'rate'

One way to use multiple constructors is using *args But that's not for today....

Python natively does not support function overloading - having multiple functions with the same name.

So friends that was all for today! Let us understand how inheritance is implemented in Python tomorrow.