PYTHON

LECTURE 44
 Today’s Agenda

• Advance Concepts Of Object Oriented

Programming-II

• Inheritance
• Types Of Inheritance
• Single Inheritance
• Using super( )
• Method Overriding
 Inheritance

 Inheritance is a powerful feature in object oriented

programming.

 It refers to defining a new class with little or no

modification to an existing class.

 The new class is called derived (or child) class and the

one from which it inherits is called the base (or parent)
class.
Real Life Examples
Real Life Examples
 Benefits

 It represents real-world relationships well.

 It provides reusability of a code. We don’t have to write

the same code again and again.

 It also allows us to add more features to a class without

modifying it.
Types Of Inheritance
Supported By Python
 Syntax Of Single Inheritance
In Python

class BaseClass:
Body of base class

class DerivedClass(BaseClass):
Body of derived class
For Ex:
class Account:
pass
class SavingAccount(Account):
pass
 Example

class Animal: duck=Bird()

duck.set_type("Duck")
def eat(self):
print(duck)
print("It eats.") duck.eat()
def sleep(self): duck.sleep()
print("It sleeps.") duck.fly()
duck.speak("Quack")
class Bird(Animal):
Output:
def set_type(self,type):
self.type=type
def fly(self):
print("It flies in the sky.")
def speak(self,sound):
print(f"It speaks:{sound},{sound}")
def __repr__(self):
return "This is a "+self.type;
 Using super()

 In Python , to call parent class members from the child

class we can use the method super( ).

 Using super() is required in 2 situations:

 For calling parent class constructor

 For calling overridden methods

 How Constructors Behave
In Inheritance ?

 Whenever we create a child class object , Python looks

for __init__() method in child class.

 If the child class doesn’t contain an __init__() method

then Python goes up in the inheritance chain and looks for
the __init__() method of parent class
 How Constructors Behave
In Inheritance ?

 If the parent class contains __init__() , then it execute it .

 Now an important point to notice is that if child class

also has __init__() , then Python will not call parent’s
__init__() method.

 That is , unlike Java or C++ , Python does not

automatically call the parent class __init__() if it finds an
__init__() method in child class
 How Constructors Behave
In Inheritance ?

class A:
def __init__(self):
print("Instantiating A...")
As you can see,
class B(A): Python called the
constructor of class
pass
A , since B class
doesn’t has any
b=B() constructor defined
Output:
 How Constructors Behave
In Inheritance ?

class A:
def __init__(self):
print("Instantiating A...")
This time , Python
class B(A): did not call the
constructor of class
def __init__(self):
A as it found a
print("Instantiating B...") constructor in B
itself
b=B()
Output:
 How Constructors Behave
In Inheritance ?

 So , what is the problem if parent constructor

doesn’t get called ?

 The problem is that , if parent class constructor doesn’t

get called then all the instance members it creates will
not be made available to child class
 How Constructors Behave
In Inheritance ?

class Rectangle: Since , constructor of

def __init__(self): Rectangle was not
called , so the
self.l=10
expression self.l
self.b=20 produced exception
class Cuboid(Rectangle): because there is no
def __init__(self): attribute created by
self.h=30 the name of l
def volume(self):
print("Vol of cuboid is",self.l*self.b*self.h)
obj=Cuboid()
obj.volume()
Output:
 How Can We Explicitly
Call __init__() Of
Parent Class ?

 If we want to call the parent class __init__() , then we

will have 2 options:

 Call it using the name of parent class explicitly

 Call it using the method super()

 Calling Parent Constructor
Using Name

class Rectangle:
def __init__(self): Notice that we have
to explicitly pass the
self.l=10
argument self while
self.b=20 calling __init__()
method of parent
class Cuboid(Rectangle): class
def __init__(self):
Rectangle.__init__(self)
self.h=30
def volume(self):
print("Vol of cuboid is",self.l*self.b*self.h)

obj=Cuboid()
obj.volume()
Output:
 Calling Parent Constructor
Using super( )

class Rectangle: Again notice that this

def __init__(self): time we don’t have to
self.l=10 pass the argument
self.b=20 self when we are
using super( ) as
Python will
class Cuboid(Rectangle):
automatically pass it
def __init__(self):
super().__init__();
self.h=30
def volume(self):
print("Vol of cuboid is",self.l*self.b*self.h)

obj=Cuboid()
obj.volume()
Output:
 What Really Is super( ) ?

 The method super() is a special method made available

by Python which returns a proxy object that delegates
method calls to a parent class

 In simple words the method super( ) provides us a special

object that can be used to transfer call to parent class
methods
 Benefits Of super( )

 A common question that arises in our mind is that why to use super( )
, if we can call the parent class methods using parent class name.

 The answer is that super( ) gives 4 benefits:

 We don’t have to pass self while calling any method using super( ).

 If the name of parent class changes after inheritance then we will not have to
rewrite the code in child as super( ) will automatically connect itself to current
parent

 It can be used to resolve method overriding

 It is very helpful in multiple inheritance

 Method Overriding

 To understand Method Overriding , try to figure out the

output of the code given in the next slide
 Guess The Output ?

class Person:
def __init__(self,age,name):
self.age=age
self.name=name
def __repr__(self):
return f"Age:{self.age},Name:{self.name}"
class Emp(Person):
def __init__(self,age,name,id,sal):
super().__init__(age,name)
self.id=id
self.sal=sal

e=Emp(24,"Nitin",101,45000)
print(e)
Output:
 Explanation

 As we know , whenever we pass the name of an object

reference as argument to the function print( ) ,
Python calls the method __repr__().

 But since the class Emp doesn’t has this method , so

Python moves up in the inheritance chain to find this
method in the base class Person

 Now since the class Person has this method , Python calls
the __repr__() method of Person which returns only
the name and age
 Method Overriding

 Now if we want to change this behavior and show all 4

attributes of the Employee i.e. his name , age ,id and
salary, then we will have to redefine the method
__repr__() in our Emp class.

 This is called Method Overriding

 Thus , Method Overriding is a concept in OOP which

occurs whenever a derived class redefines the same
method as inherited from the base class
 Modified Example

class Person:
def __init__(self,age,name):
self.age=age
self.name=name
def __repr__(self):
return f"Age:{self.age},Name:{self.name}"
class Emp(Person):
def __init__(self,age,name,id,sal):
super().__init__(age,name)
self.id=id
self.sal=sal
def __repr__(self):
return f"Age:{self.age},Name:{self.name},Id:{self.id},Salary:{self.sal}"
e=Emp(24,"Nitin",101,45000)
print(e)
Output:
 Role Of super( )
In Method Overriding

 When we override a method of base class in the

derived class then Python will always call the derive’s
version of the method.

 But in some cases we also want to call the base class

version of the overridden method.

 In this case we can call the base class version of the

method from the derive class using the function super( )
 Syntax:
super( ). <method_name>(<arg>)
 Modified Example

class Person:
def __init__(self,age,name):
self.age=age
self.name=name
def __repr__(self):
return f"Age:{self.age},Name:{self.name}"
class Emp(Person):
def __init__(self,age,name,id,sal):
super().__init__(age,name)
self.id=id
self.sal=sal
def __repr__(self):
str=super().__repr__()
return f"{str},Id:{self.id},Salary:{self.sal}"
e=Emp(24,"Nitin",101,45000)
print(e)
Output:
 Exercise

 Write a program to create a class called Circle having an instance member called radius.
Provide following methods in Circle class

 __init___() : This method should accept an argument and initialize radius with it

 area(): This method should calculate and return Circle’s area

 Now create a derived class of Circle called Cylinder having an instance member called
height. Provide following methods in Cylinder class

 __init___() : This method should initialize instance members radius and height with the
parameter passed.

 area( ): This method should override Circle’s area( ) to calculate and return area of Cylinder .
( formula: 2πr2+2πrh)

 volume(): This method should calculate and return Cylinder’s volume(formula: πr2h)
 Solution

import math obj=Cylinder(10,20)

class Circle: print("Area of cylinder is",obj.area())
def __init__(self,radius): print("Volume of cylinder is",obj.volume())
self.radius=radius
def area(self):
return math.pi*math.pow(self.radius,2)
class Cylinder(Circle):
def __init__(self,radius,height):
super().__init__(radius)
self.height=height
def area(self):
return 2*super().area()+2*math.pi*self.radius*self.height
def volume(self):
return super().area()*self.height

Output:
 A Very Important Point!

 Can we call the base class version of an overridden

method from outside the derived class ?

 For example , in the previous code we want to call the

method area( ) of Circle class from our main script .
How can we do this ?

 Yes this is possible and for this Python provides us a

special syntax:

 Syntax:
<base_class_name>.<method_name>(<der_obj>)
 Example

import math obj=Cylinder(10,20)

class Circle: print("Area of cylinder is",obj.area())
def __init__(self,radius): print("Volume of cylinder is",obj.volume())
print("Area of Circle:",Circle.area(obj))
self.radius=radius
def area(self):
return math.pi*math.pow(self.radius,2)
class Cylinder(Circle): By calling in this way
def __init__(self,radius,height): we can bypass the
area( ) method of
super().__init__(radius)
Cylinder and directly
self.height=height call area( ) method
def area(self): of Circle
return 2*super().area()+2*math.pi*self.radius*self.height
def volume(self):
return super().area()*self.height

Output: