'Constructors' or the '__init__( )' method provides us a way to initialise the attributes of the class while an object is created.
The '__init__( )' method looks a little different from the other methods. i.e. It starts with two underscores '__' and ends with two underscores '__' .
Well ! That is because it is not like a normal method and is called a 'Constructor' .
There are two types of Constructor :
The '__init__( )' method with no arguments is the 'Default Constructor' . It is called so because, even though we don't call the '__init__( )' method, it is automatically called at the time of Object creation.
Let us see in the below example .
class Human:
def eat(self):
print(self.name," eats ",self.food)
def speak(self):
print(self.name," speaks ",self.language)
def __init__(self):
print("__init__() method is called during object creation")
human1 = Human()
In the above example , we have create the 'Human' class,
class Human:
def eat(self):
print(self.name," eats ",self.food)
def speak(self):
print(self.name," speaks ",self.language)
def __init__(self):
print("__init__() method is called during object creation")
With the '__init__( )' method,
def __init__(self):
print("__init__() method is called during object creation")
Just to demonstrate that you don't have to call the '__init__( )' method separately. But it would be called automatically, at the time of object creation.
So , the moment we create the object using 'Human( )', '__init__( )' method is called automatically and we get the below output .
Now , let us see, how can we initialise all the attributes of the 'Human' class using the Constructor with Arguments.
Let us take the same 'Human' class from the previous tutorial.
class Human:
def __init__(self, name, food, language):
self.name = name
self.food = food
self.language = language
def eat(self):
print(self.name," eats ",self.food)
def speak(self):
print(self.name," speaks ",self.language)
human1 = Human("John", "Burger", "English")
human2 = Human("Rakhi", "Rice", "Hindi")
human1.eat()
human1.speak()
human2.eat()
human2.speak()
Now , the above example has a structured way of defining the attributes of the class( i.e. 'name', 'food' and 'language' ).
All we have done is, while creating the object 'human1' , we have passed the values, "John","Burger" and "English" as Arguments.
And what happens is, the constructor, 'init(...)' with three Arguments is called.
def __init__(self, name, food, language):
self.name = name
self.food = food
self.language = language
And "John" gets initialised to the variable 'name', "Burger" to 'food' and "English" to the variable 'language' .
And 'self' refers to 'human1' object.
But ! Hold on !
The values are not yet a part of the 'human1' Object. They becomes a part of 'human1' Object in the next lines.
As 'self' refers to 'human1' object.
And
Takes the value 'John' from the local variable 'name' and puts it to the 'name' attribute of the 'Human' class.
Similarly , the next two lines ,
Assigns the values 'Burger' and 'English' to the 'food' and 'language' attribute of the 'human1' object.
And the 'human1' object has the values now.
Similarly , the next line ,
Assigns the values to the 'human2' object.
Let us take the same example . So , 'John' speaks 'English' .
Now , let's say we want to modify the language of 'John' to 'Spanish' . Let modify the same example.
class Human:
def __init__(self, name, food, language):
self.name = name
self.food = food
self.language = language
def eat(self):
print(self.name," eats ",self.food)
def speak(self):
print(self.name," speaks ",self.language)
human1 = Human("John", "Burger", "English")
human2 = Human("Rakhi", "Rice", "Hindi")
human1.language = "Spanish"
human1.eat()
human1.speak()
human2.eat()
human2.speak()
And all we have done is, added the line ,
And the 'language' attribute of 'human1' object got changed to 'Spanish' .
And we got the below output .