Padmashri Dr.

Vitthalrao Vikhe Patil Institute Of Technology & Engineering (Polytechnic ), Pravaranagar

PWP-22616,BD

Unit V
Object Oriented Programming In Python

5a. Creating Classes and Objects to solve the given problem

5b Write Python code for data hiding for the given problem
5c. Write Python code using data abstraction for the given problem
5d. Write Python program using inheritance for the for the given problem

1
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology & Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

Python OOPs Concepts

 Python is an object-oriented programming language.
 It allows us to develop applications using an Object Oriented approach. In Python, we
can easily create and use classes and objects.
 Major principles of object-oriented programming system are given below.
o Object
o Class
o Method
o Inheritance
o Polymorphism
o Data Abstraction
o Encapsulation

Object
 The object is an entity that has state and behavior. It may be any real-world object like
the mouse, keyboard, chair, table, pen, etc.
 Everything in Python is an object, and almost everything has attributes and methods. All
functions have a built-in attribute __doc__, which returns the doc string defined in the
function source code.
Class
 The class can be defined as a collection of objects. It is a logical entity that has some
specific attributes and methods. For example: if you have an Student class then it should
contain an attribute and method, i.e. an email id, name, age, salary, etc.
 Syntax
class ClassName:
<statement-1>
.
.
<statement-N>
Method
 The method is a function that is associated with an object. In Python, a method is not
unique to class instances. Any object type can have methods.
Inheritance
 Inheritance is the most important aspect of object-oriented programming which simulates
the real world concept of inheritance. It specifies that the child object acquires all the
properties and behaviors of the parent object.
 By using inheritance, we can create a class which uses all the properties and behavior of
another class. The new class is known as a derived class or child class, and the one whose
properties are acquired is known as a base class or parent class.
 It provides re-usability of the code.
Polymorphism
 Polymorphism contains two words "poly" and "morphs". Poly means many and Morphs
means form, shape.
 By polymorphism, we understand that one task can be performed in different ways.

2
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

 For example You have a class animal, and all animals speak. But they speak differently.
Here, the "speak" behavior is polymorphic in the sense and depends on the animal. So,
the abstract "animal" concept does not actually "speak", but specific animals (like dogs
and cats) have a concrete implementation of the action "speak".
Encapsulation
 Encapsulation is also an important aspect of object-oriented programming.
 It is used to restrict access to methods and variables.
 In encapsulation, code and data are wrapped together within a single unit from being
modified by accident.
Data Abstraction
 Data abstraction and encapsulation both are often used as synonyms. Both are nearly
synonym because data abstraction is achieved through encapsulation.
 Abstraction is used to hide internal details and show only functionalities.
 Abstracting something means to give names to things so that the name captures the core
of what a function or a whole program does.
Object-oriented vs Procedure-oriented Programming languages
Object-oriented Programming Procedural Programming
Object-oriented programming is the Procedural programming uses a list of
problem-solving approach and used instructions to do computation step by
where computation is done by using step.
objects.
It makes the development and In procedural programming, It is not
maintenance easier. easy to maintain the codes when the
project becomes lengthy.
It simulates the real world entity. So real- It doesn't simulate the real world. It
world problems can be easily solved works on step by step instructions
through oops. divided into small parts called
functions.
It provides data hiding. So it is more Procedural language doesn't provide
secure than procedural languages. You any proper way for data binding, so it is
cannot access private data from less secure.
anywhere.
Example of object-oriented programming Example of procedural languages are:
languages is C++, Java, .Net, Python, C, Fortran, Pascal, VB etc.
C#, etc.

3
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

Python Class and Objects

 As we have already discussed, a class is a virtual entity and can be seen as a blueprint of
an object. The class came into existence when it instantiated.
 Let's understand it by an example.
 Suppose a class is a prototype of a building. A building contains all the details about the
floor, doors, windows, etc. we can make as many buildings as we want, based on these
details. Hence, the building can be seen as a class, and we can create as many objects of
this class.
 On the other hand, the object is the instance of a class. The process of creating an object
can be called as instantiation.

Creating classes in python

 In python, a class can be created by using the keyword class followed by the class name.
The syntax to create a class is given below.
 Syntax
class ClassName:
#statement_suite
 In python, we must notice that each class is associated with a documentation string which
can be accessed by using <class-name>.__doc__.
 A class contains a statement suite including fields, constructor, function, etc. definition.
 Consider the following example to create a class Student which contains two fields as
Student rollno, and name.
 The class also contains a function display() which is used to display the information of
the Student.
 Example
class Student:
id = 10;
name = "rakesh"
def display (self):
print(self.id,self.name)
 Here, the self is used as a reference variable which refers to the current class object. It is
always the first argument in the function definition. However, using self is optional in the
function call.

Creating an instance of the class

 A class needs to be instantiated if we want to use the class attributes in another class or
method.
 A class can be instantiated by calling the class using the class name.
 The syntax to create the instance of the class is given below.
<object-name> = <class-name>(<arguments>)
 The following example creates the instance of the class Student defined in the above
example.

4
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

class Student:
id = 10;
name = "Rakesh"
def display (self):
print("ID: %d \nName: %s"%(self.id,self.name))
stud = Student()
stud.display()
Output:

ID: 10
Name: Rakesh

Python Constructor
 A constructor is a special type of method (function) which is used to initialize the
instance members of the class.
 Constructors can be of two types.
1. Parameterized Constructor
2. Non-parameterized Constructor
 Constructor definition is executed when we create the object of this class. Constructors
also verify that there are enough resources for the object to perform any start-up task.

Creating the constructor in python

 In python, the method __init__ simulates the constructor of the class.
 This method is called when the class is instantiated.
 We can pass any number of arguments at the time of creating the class object, depending
upon __init__ definition.
 It is mostly used to initialize the class attributes. Every class must have a constructor,
even if it simply relies on the default constructor.
 Consider the following example to initialize the Student class attributes.
class Student:
def __init__(self,name,id):
self.id = id;
self.name = name;
def display (self):
print("ID: %d \nName: %s"%(self.id,self.name))
stud1 = Student("Rakesh",101)
stud2 = Student("Sachin",102)
#accessing display() method to print Student information
stud1.display();
#accessing display() method to print Student 2 information
stud2.display();

5
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

Output:

ID: 101
Name: Rakesh
ID: 102
Name: Sachin
 Example: Counting the number of objects of a class
class Student:
count = 0
def __init__(self):
Student.count = Student.count + 1
s1=Student()
s2=Student()
s3=Student()
print("The number of students:",Student.count)
Output:
The number of students: 3
 Python Non-Parameterized Constructor Example
class Student:
# Constructor - non parameterized
def __init__(self):
print("This is non parametrized constructor")
def show(self,name):
print("Hello",name)
student = Student()
student.show("Rakesh")
Output:
This is non parametrized constructor
Hello Rakesh
 Python Parameterized Constructor Example
class Student:
# Constructor - parameterized
def __init__(self, name):
print("This is parametrized constructor")
self.name = name
def show(self):
print("Hello",self.name)
student = Student("Rakesh")
student.show()

6
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

Output:
This is parametrized constructor
Hello Rakesh
Destructor:
A class can define a special method called destructor with the help of _ _del_ _().
It is invoked automatically when the instance (object) is about to be destroyed.
It is mostly used to clean up non memory resources used by an instance(object).
Example: For Destructor
class student:
def __init__(self):
print("This is non parameterized constructor")
def __del__(self):
print("Destructor called")
s1=student()
s2=student()
del s1
Output:
This is non parameterized constructor
This is non parameterized constructor
Destructor called
Python In-built class functions
 The in-built functions defined in the class are described in the following table.
Sr. No. Function Description
1 getattr(obj,name,default) It is used to access the attribute of
the object.
2 setattr(obj, name,value) It is used to set a particular value to
the specific attribute of an object
.
3 delattr(obj, name) It is used to delete a specific
attribute.
4 hasattr(obj, name) It returns true if the object contains
some specific attribute.
 Example
class Student:
def __init__(self,name,id,age):
self.name = name;
self.id = id;
self.age = age

#creates the object of the class Student

s = Student("Rakesh",101,22)

#prints the attribute name of the object s

print(getattr(s,'name'))

7
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

# reset the value of attribute age to 23

setattr(s,"age",23)

# prints the modified value of age

print(getattr(s,'age'))

# prints true if the student contains the attribute with name id

print(hasattr(s,'id'))
# deletes the attribute age
delattr(s,'age')

# this will give an error since the attribute age has been deleted
print(s.age)
Output:
Rakesh
23
True
AttributeError: 'Student' object has no attribute 'age'
Built-in class attributes
 Along with the other attributes, a python class also contains some built-in class attributes
which provide information about the class.
 The built-in class attributes are given in the below table.
Sr. No. Attribute Description
1 __dict__ It provides the dictionary containing the
information about the class namespace.
2 __doc__ It contains a string which has the class
documentation
3 __name__ It is used to access the class name.
4 __module__ It is used to access the module in which,
this class is defined.
5 __bases__ It contains a tuple including all base
classes.
 Example
class Student:
def __init__(self,name,id,age):
self.name = name;
self.id = id;
self.age = age
def display_details(self):
print("Name:%s, ID:%d, age:%d"%(self.name,self.id))

8
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

s = Student("John",101,22)
print(s.__doc__)
print(s.__dict__)
print(s.__module__)
Output:
None
{'name': 'John', 'id': 101, 'age': 22}
__main__
Method Overloading:
• Method overloading is the ability to define the method with the same name
but with a different number of arguments and data types.
• With this ability one method can perform different tasks, depending on the number of
arguments or the types of the arguments given.
• Method overloading is a concept in which a method in a class performs operations according to
the parameters passed to it.
• As in other language we can write a program having two methods with same name but with
different number of arguments or order of arguments but in python if we will try to do the same
we get the following issue with method overloading in python.
Example-
# To calculate area of rectangle
def area(length,breadth):
calc=length*breadth
print(calc)
# To calculate area of square
def area(size):
calc=size*size
print(calc)
area(3)
area(4,5)
Output-
9
Traceback (most recent call last):
File "D:\python programs\trial.py", line 10, in <module>
area(4,5)
TypeError: area() takes 1 positional argument but 2 were given
• Python does not support method overloading i.e it is not possible to define more than one
method with the same name in a class in python.
• This is because method arguments in python do not have a type. A method accepting one
argument can be called with an integer value, a string or a double as shown in example.
Example
Class demo:
def print_r(self,a,b):
print(a)
print(b)
obj=demo()

9
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

obj.print_r(10,'S')
obj.print_r('S',10)
Output:
10
S
S
10
• In the above example same method works for two different data types.
• It is clear that method overloading is not supported in python but that does not mean that we
cannot call a method with different number of arguments. There are couple of alternatives
available in python that make it possible to call the same method but with different number of
arguments.

Using Default Arguments:

It is possible to provide default values to method arguments while defining a method. If method
arguments are supplied default values, then it is not mandatory to supply those arguments while
calling method as shown in example.
Example 1: Method overloading with deafult arguments
class demo:
def arguments(self,a=None,b=None,c=None):
if(a!=None and b!=None and c!=None):
print("3 arguments")
elif (a!=None and b!=None):
print("2 arguments")
elif a!=None:
print("1 argument")
else:
print("0 arguments")
obj=demo()
obj.arguments("Amol","Kedar","Sanjay")
obj.arguments("Amit","Rahul")
obj.arguments("Sidharth")
obj.arguments()
Output-
3 arguments
2 arguments
1 argument
0 arguments
Example 2: With a method to perform different operations using method
overloading
class operation:
def add(self,a,b):
return a+b
op=operation()
# To add two integer numbers
print("Addition of integer numbers= ",op.add(10,20))

10
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

# To add two floating numbers

print("Addition of integer numbers= ",op.add(11.12,12.13))
# To add two strings
print("Addition of stings= ",op.add("Hello","World"))
Output-
Addition of integer numbers= 30
Addition of integer numbers= 23.25
Addition of stings= HelloWorld
Inheritance:
The mechanism of designing and constructing classes from other classes
is called inheritance.
Inheritance is the capability of one class to derive or inherit the properties from some another
class. The new class is called derived class or child class and the class from which this derived
class has been inherited is the base class or parent class. The benefits of inheritance are:
1. It represents real-world relationships well.
2. It provides reusability of a code. We don’t have to write the same code again and again. Also,
it allows us to add more features to a class without modifying it.
3. It is transitive in nature, which means that if class B inherits from another class A, then all the
subclasses of B would automatically inherit from class A.

Syntax:
Class A:
# Properties of class A
Class B(A):
# Class B inheriting property of class A
# more properties of class B
Example 1: Example of Inheritance without using constructor
class vehicle: #parent class
name="Maruti"
def display(self):
print("Name= ",self.name)

11
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

class category(vehicle): # drived class

price=400000
def disp_price(self):
print("price= ",self.price)
car1=category()
car1.display()
car1.disp_price()
Output:
Name= Maruti
price= 400000

Example 2: Example of Inheritance using constructor

class vehicle: #parent class
def __init__(self,name,price):
self.name=name
self.price=price
def display(self):
print("Name= ",self.name)
class category(vehicle): # drived class
def __init__(self,name,price):
vehicle.__init__(self,name,price) #pass data to base constructor
def disp_price(self):
print("price= ",self.price)
car1=category("Maruti",400000)
car1.display()
car1.disp_price()
car2=category("Honda",600000)
car2.display()
car2.disp_price()
Output:
Name= Maruti
price= 400000
Name= Honda
price= 600000

Multilevel Inheritance:
In multilevel inheritance, features of the base class and the derived class are further inherited into
the new derived class. This is similar to a relationship representing a child and grandfather.

12
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

Syntax:
Class A:
# Properties of class A
Class B(A):
# Class B inheriting property of class A
# more properties of class B
Class C(B):
# Class C inheriting property of class B
# thus, Class C also inherits properties of class A
# more properties of class C

Example 1: Python program to demonstrate multilevel inheritance

#Mutilevel Inheritance
class c1:
def display1(self):
print("class c1")
class c2(c1):
def display2(self):
print("class c2")
class c3(c2):
def display3(self):
print("class c3")
s1=c3()
s1.display3()
s1.display2()
s1.display1()
Output:
class c3
class c2
class c1

13
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

Example 2: Python program to demonstrate multilevel inheritance

# Base class
class Grandfather:
grandfathername =""
def grandfather(self):
print(self.grandfathername)
# Intermediate class
class Father(Grandfather):
fathername = ""
def father(self):
print(self.fathername)
# Derived class
class Son(Father):
def parent(self):
print("GrandFather :", self.grandfathername)
print("Father :", self.fathername)
# Driver's code
s1 = Son()
s1.grandfathername = "Srinivas"
s1.fathername = "Ankush"
s1.parent()
Output:
GrandFather : Srinivas
Father : Ankush

Multiple Inheritance:
When a class can be derived from more than one base classes this type of inheritance is called
multiple inheritance. In multiple inheritances, all the features of the base classes are inherited
into the derived class.

Syntax:
Class A:
# variable of class A
# functions of class A
Class B:

14
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

# variable of class B
# functions of class B
Class C(A,B):
# Class C inheriting property of both class A and B
# more properties of class C
Example: Python program to demonstrate multiple inheritances
# Base class1
class Father:
def display1(self):
print("Father")
# Base class2
class Mother:
def display2(self):
print("Mother")
# Derived class
class Son(Father,Mother):
def display3(self):
print("Son")
s1 = Son()
s1.display3()
s1.display2()
s1.display1()
Output:
Son
Mother
Father

Hierarchical Inheritance:
When more than one derived classes are created from a single base this type of inheritance is
called hierarchical inheritance. In this program, we have a parent (base) class and two child
(derived) classes.

15
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

Example : Python program to demonstrate Hierarchical inheritance

# Base class
class Parent:
def func1(self):
print("This function is in parent class.")
# Derived class1
class Child1(Parent):
def func2(self):
print("This function is in child 1.")
# Derived class2
class Child2(Parent):
def func3(self):
print("This function is in child 2.")
object1 = Child1()
object2 = Child2()
object1.func1()
object1.func2()
object2.func1()
object2.func3()
Output:
This function is in parent class.
This function is in child 1.
This function is in parent class.
This function is in child 2.

The issubclass(sub,sup) method

 The issubclass(sub, sup) method is used to check the relationships between the
specified classes. It returns true if the first class is the subclass of the second class, and
false otherwise.
 Consider the following example.
 Example
class Calculation1:
def Summation(self,a,b):
return a+b;
class Calculation2:
def Multiplication(self,a,b):
return a*b;
class Derived(Calculation1,Calculation2):
def Divide(self,a,b):
return a/b;
d = Derived()
print(issubclass(Derived,Calculation2))
print(issubclass(Calculation1,Calculation2))

16
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

Output:
True
False

The isinstance (obj, class) method

 The isinstance() method is used to check the relationship between the objects and
classes. It returns true if the first parameter, i.e., obj is the instance of the second
parameter, i.e., class.
 Example
class Calculation1:
def Summation(self,a,b):
return a+b;
class Calculation2:
def Multiplication(self,a,b):
return a*b;
class Derived(Calculation1,Calculation2):
def Divide(self,a,b):
return a/b;
d = Derived()
print(isinstance(d,Derived))
Output:
True

Method Overriding
 We can provide some specific implementation of the parent class method in our child
class. When the parent class method is defined in the child class with some specific
implementation, then the concept is called method overriding. We may need to
perform method overriding in the scenario where the different definition of a parent
class method is needed in the child class.
 Consider the following example to perform method overriding in python.
class Animal:
def speak(self):
print("speaking")
class Dog(Animal):
def speak(self):
print("Barking")
d = Dog()
d.speak()
Output:
Barking

17
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

 Real Life Example of method overriding

class Bank:
def getroi(self):
return 10;
class SBI(Bank):
def getroi(self):
return 7;

class ICICI(Bank):
def getroi(self):
return 8;
b1 = Bank()
b2 = SBI()
b3 = ICICI()
print("Bank Rate of interest:",b1.getroi());
print("SBI Rate of interest:",b2.getroi());
print("ICICI Rate of interest:",b3.getroi());
Output:
Bank Rate of interest: 10
SBI Rate of interest: 7
ICICI Rate of interest: 8

Data abstraction in python

 Abstraction is an important aspect of object-oriented programming. In python, we can
also perform data hiding by adding the double underscore (___) as a prefix to the
attribute which is to be hidden. After this, the attribute will not be visible outside of
the class through the object.
 Consider the following example.
class Employee:
__count = 0;
def __init__(self):
Employee.__count = Employee.__count+1
def display(self):
print("The number of employees",Employee.__count)
emp = Employee()
emp2 = Employee()
try:
print(emp.__count)
finally:
emp.display()

18
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

Output:
The number of employees 2
Attribute Error: 'Employee' object has no attribute '__count'
Method Overriding:
Method overriding is an ability of a class to change the implementation of a method provided
by one of its base class. Method overriding is thus a strict part of inheritance mechanism.
To override a method in base class, we must define a new method with same name and same
parameters in the derived class.
Overriding is a very important part of OOP since it is feature that makes inheritance exploit its
full power. Through method overriding a class may “copy” another class, avoiding duplicated
code and at the same time enhance or customize part of it.
Example: For method overriding
class A:
def display(self):
print("This is base class")
class B(A):
def display(self):
print("This is derived class")
obj=B() # instance of child
obj.display() # child class overriden method
Output-
This is derived class
Using super() Method:
The super() method gives you access to methods in a super class from the
subclass that inherits from it.
The super() method returns a temporary object of the superclass that then
allows you to call that superclass’s method.
Example: For method overriding with super()
class A:
def display(self):
print("This is base class")
class B(A):
def display(self):
super().display()
print("This is derived class")
obj=B() # instance of child
obj.display() # child class overriden method
Output-
This is base class
This is derived class
Composition Classes:
• In composition we do not inherit from the base class but establish
relationship between classes through the use of instance variables that are
references to other objects.
• Composition means that an object knows another object and explicitly
delegates some tasks to it. While inheritance is implicit, composition is

19
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

explicit in python.
• We use composition when we want to use some aspects of another class
without promising all of the features of that other class.
Syntax:
Class GenericClass:
Define some attributes and methods
Class AspecificClass:
Instance_variable_of_generic_class=GenericClass
#use this instance somewhere in the class
Some_method(instance_varable_of_generic_class)
• For example, we have three classes email, gmail and yahoo. In email class
we are referring the gmail and using the concept of composition.
Example:
class gmail:
def send_email(self,msg):
print("sending '{}' from gmail".format(msg))
class yahoo:
def send_email(self,msg):
print("sending '{}' from yahoo".format(msg))
class email:
provider=gmail()
def set_provider(self,provider):
self.provider=provider
def send_email(self,msg):
self.provider.send_email(msg)
client1=email()
client1.send_email("Hello")
client1.set_provider(yahoo())
client1.send_email("Hello")
Output:
sending 'Hello' from gmail
sending 'Hello' from yahoo
Customization via Inheritance specializing inherited methods:
• The tree-searching model of inheritance turns out to be a great way to specialize systems.
Because inheritance finds names in subclasses before it checks superclasses, subclasses can
replace default behavior by redefining the superclass's attributes.
• In fact, you can build entire systems as hierarchies of classes, which are extended by adding
new external subclasses rather than changing existing logic in place.
• The idea of redefining inherited names leads to a variety of specialization techniques.
• For instance, subclasses may replace inherited attributes completely, provide attributes that a
superclass expects to find, and extend superclass methods by calling back to the superclass
from an overridden method.

20
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

Example- For specialized inherited methods

class A:
"parent class" #parent class
def display(self):
print("This is base class")
class B(A):
"Child class" #derived class
def display(self):
A.display(self)
print("This is derived class")
obj=B() #instance of child
obj.display() #child calls overridden method
Output:
This is base class
This is derived class
• In the above example derived class.display() just extends base class.display()
behavior rather than replacing it completely.
• Extension is the only way to interface with a superclass.
• The following program defines multiple classes that illustrate a variety of
common techniques.
Super
Defines a method function and a delegate that expects an action in a
subclass
Inheritor
Doesn't provide any new names, so it gets everything defined in Super
Replacer
Overrides Super's method with a version of its own
Extender
Customizes Super's method by overriding and calling back to run the
default
Provider
Implements the action method expected by Super's delegate method
Example- Various ways to customize a common superclass
class super:
def method(self):
print("in super.method") #default behavior
def delegate(self):
self.action() #expected to be defined
class inheritor(super):
pass
class replacer(super): #replace method completely
def method(self):
print("in replacer.method")
class extender(super): #extend method behavior
def method(self):
super.method(self)

21
 Padmashri Dr. Vitthalrao Vikhe Patil Institute Of Technology &amp; Engineering (Polytechnic ), Pravaranagar
PWP-22616,BD

print("in extender.method")
class provider(super): # fill in a required method
def action(self):
print("in provider.action“)
for klass in (inheritor,replacer,extender):
print("\n"+klass.__name__+"...")
klass().method()
print("\n provider...")
x=provider()
x.delegate()
Output:
inheritor...
in super.method
provider...
replacer...
in replacer.method
provider...
extender...
in super.method
in extender.method
provider...
in provider.action
• When we call the delegate method through provider instance, two independent inheritance
searches occur:
• On the initial x.delegate call, Python finds the delegate method in Super, by searching at the
provider instance and above. The instance x is passed into the method's self argument as usual.
• Inside the super.delegate method, self.action invokes a new, independent inheritance search at
self and above. Because self references a provider instance, the action method is located in the
provider subclass.

22