No, it isn't necessary.
For example.
class A[object]:
def f[]:
print 'foo'
And you can of course use it, in this manner:
a = A[]
a.f[]
In fact you can even define a class in this manner.
class A:
pass
However, defining __init__
is a common practice because instances of a class usually store some sort of state information or data and the methods of the class offer a way to manipulate or do something with that state information or data. __init__
allows us to initialize this state information or
data while creating an instance of the class.
Here is a complete example.
class BankAccount[object]:
def __init__[self, deposit]:
self.amount = deposit
def withdraw[self, amount]:
self.amount -= amount
def deposit[self, amount]:
self.amount += amount
def balance[self]:
return self.amount
# Let me create an instance of 'BankAccount' class with the initial
# balance as $2000.
myAccount = BankAccount[2000]
# Let me check if the balance is right.
print myAccount.balance[]
# Let me deposit my salary
myAccount.deposit[10000]
# Let me withdraw some money to buy dinner.
myAccount.withdraw[15]
# What's the balance left?
print myAccount.balance[]
An instance of the class is always passed as the first argument to a method of the class. For example if there is class A
and you have an instance a = A[]
, whenever you call a.foo[x, y]
, Python
calls foo[a, x, y]
of class A
automatically. [Note the first argument.] By convention, we name this first argument as self
.
Prerequisites – Python Class, Objects, Self Whenever object-oriented programming is done in Python, we mostly come across __init__ method in oops which we usually don’t fully understand. This article explains the main concept of __init__ but before understanding the __init__ some prerequisites are required.
What is __init__ in Python?
The Default __init__ Constructor in C++ and Java. Constructors are used to initializing the object’s state. The task of constructors is to initialize[assign values] to the data members of the class when an object of the class is created. Like methods, a constructor also contains a collection of statements[i.e. instructions] that are executed at the time of Object creation. It is run as soon as an object of a class is instantiated. The method is useful to do any initialization you want to do with your object.
Example:
Python3
class
Person:
def
__init__[
self
, name]:
self
.name
=
name
def
say_hi[
self
]:
print
[
'Hello, my name is'
,
self
.name]
p
=
Person[
'Nikhil'
]
p.say_hi[]
Output:
Hello, my name is Nikhil
Understanding the code
In the above example, a person name Nikhil is created. While creating a person, “Nikhil” is passed as an argument, this argument will be passed to the __init__ method to initialize the object. The keyword self represents the instance of a class and binds the attributes with the given arguments. Similarly, many objects of the Person class can be created by passing different names as arguments. Below is the example of init in python with parameters
Example of __init__
Python3
class
Person:
def
__init__[
self
, name]:
self
.name
=
name
def
say_hi[
self
]:
print
[
'Hello, my name is'
,
self
.name]
p1
=
Person[
'Nikhil'
]
p2
=
Person[
'Abhinav'
]
p3
=
Person[
'Anshul'
]
p1.say_hi[]
p2.say_hi[]
p3.say_hi[]
Output:
Hello, my name is Nikhil Hello, my name is Abhinav Hello, my name is Anshul
__init__ with inheritance
Inheritance is the capability of one class to derive or inherit the properties from some other class. Let’s consider the below example to see how __init__ works in inheritance.
Python3
class
A[
object
]:
def
__init__[
self
, something]:
print
[
"A init called"
]
self
.something
=
something
class
B[A]:
def
__init__[
self
, something]:
A.__init__[
self
, something]
print
[
"B init called"
]
self
.something
=
something
obj
=
B[
"Something"
]
Output:
A init called B init called
So, the parent class constructor is called first. But in Python, it is not compulsory that the parent class constructor will always be called first. The order in which the __init__ method is called for a parent or a child class can be modified. This can simply be done by calling the parent class constructor after the body of the child class constructor.
Example:
Python3
class
A[
object
]:
def
__init__[
self
, something]:
print
[
"A init called"
]
self
.something
=
something
class
B[A]:
def
__init__[
self
, something]:
print
[
"B init called"
]
self
.something
=
something
A.__init__[
self
, something]
obj
=
B[
"Something"
]
Output:
B init called A init called
Note: To know more about inheritance click here.