UNIT V

OBJECT ORIENTED
PROGRAMMING IN PYTHON
 INTRODUCTION:
🞆Python follows object oriented programming paradigm. It deals
with declaring python classes and objects which lays the
foundation of OOP’s concepts.
🞆It uses the OOP concepts that makes python more powerful to
help design a program that represents real world entities.
🞆Python supports OOP concepts such as Inheritance, Method
Overriding, Data abstraction and Data hiding.
DIFFERENT OOP FEATURES SUPPORTED BY PYTHON:
🞆 Class: A class is a collection of objects or you can say it is a
blueprint of objects defining the common attributes and
behavior. Classes are defined by the user. The class provides
the basic structure for an object. It consists of data members and
method members that are used by the instances(object) of the
class.
🞆 Object: Objects are an instance of a class. It is an entity that
has state and behavior. A unique instance of a data structure
that is defined by its class. An object comprises both data
members and methods. Class itself does nothing but real
functionality is achieved through their objects.
🞆 Data Member: A variable defined in either a class or an object;
it holds the data associated with the class or object.
🞆 Instance variable: A variable that is defined in a method, its
scope is only within the object that defines it.
DIFFERENT OOP FEATURES SUPPORTED BY
PYTHON:
🞆Class variable: A variable that is defined in the class and can be
used by all the instance of that class.
🞆Instance: An object is an instance of a class.
🞆Method: They are functions that are defined in the definition of
class and are used by various instances of the class.
🞆Function Overloading: A function defined more than one time
with different behavior. (different arguments)
🞆Encapsulation: It is the process of binding together the methods
and data variables as a single entity i.e. class. It hides the data
within the class and makes it available only through the methods.
 DIFFERENT OOP FEATURES SUPPORTED
BY PYTHON:
🞆Inheritance: The transfer of characteristics of a class to other
classes that are derived from it.
🞆Polymorphism: It allows one interface to be used for a set of
actions. It means same function name(but different signatures)
being used for different types.
🞆Data abstraction: It is the process of hiding the implementation
details and showing only functionality to the user.
CREATING CLASSES:
🞆A Class is like an object constructor, or a "blueprint" for
creating objects
🞆Syntax:
class ClassName:
‘ Optional class documentation string
#list of python class variables
# Python class constructor
#Python class method definitions
🞆In a class we can define variables, functions etc. While writing
function in class we have to pass atleast one argument that is
called self parameter.
🞆The self parameter is a reference to the class itself and is used to
access variables that belongs to the class.
🞆Example: Creating class in .py file
class student:
def display(self):
print("Hello Python")
🞆In python programming self is a default variable that contains the
memory address of the instance of the current class.
🞆So we can use self to refer to all the instance variable and
instance methods.
 OBJECTS AND CREATING OBJECTS:
🞆An object is an instance of a class that has some attributes and
behavior.
🞆Objects can be used to access the attributes of the class.
🞆Syntax:
object_name=class_name()
🞆Example:
class student:
def display(self): # defining method in class
print("Hello Python")
s1=student() #creating object of class
s1.display() #calling method of class using object
🞆Output: Hello Python
 DATA HIDING:
🞆Data hiding is a software development technique specifically
used in object oriented programming to hide internal object
details(data members).
🞆Data hiding is also known as information hiding. An object
attributes may or may not be visible outside the class definition.
🞆We need to name attributes with a double underscore
(_ _) prefix and those attributes the are not directly visible to
outsiders. Any variable prefix with double underscore is called
private variable which is accessible only with class where it is
declared.
🞆Example: For data hiding
class counter:
__secretcount=0 # private variable
def count(self): # public method
self.__secretcount+=1
print("count= ",self.__secretcount)
c1=counter()
c1.count() # invoke method
c1.count()
print("Total count= ",c1.__secretcount)
🞆Output:
count= 1
count= 2
AttributeError: 'counter' object has no attribute '__secretcount'
 DATA ENCAPSULATION AND DATA
ABSTRACTION:
🞆We can restrict access of methods and variables in a class with
the help of encapsulation. It will prevent the data being modified
by accident.
🞆Data abstraction refers to providing only essential information
about the data to the outside world, hiding the background details
of implementation.
🞆Encapsulation is a process to bind data and functions together
into a single unit i.e. class while abstraction is a process in which
the data inside the class is the hidden from outside world.
🞆In short hiding internal details and showing functionality is
known as abstraction.
 ACCESS MODIFIERS FOR VARIABLES AND METHODS ARE:
🞆Public methods / variables-:
Accessible from anywhere inside the class, in the sub
class, in same script file as well as outside the script file.
🞆Private methods / variables:
Accessible only in their own class. Starts with two
underscores.
🞆 Example: For access modifiers with data abstraction
class student:
__a=10 #private variable
b=20 #public variable
def __private_method(self): #private method
print("Private method is called")
def public_method(self): #public method
print("public method is called")
print("a= ",self.__a) #can be accessible in same class
s1=student()
# print("a= ",s1.__a) #generate error
print("b=",s1.b)
# s1.__private_method() #generateerror
s1.public_method()
🞆 Output:

b= 20
public method is called
a= 10
 CREATING CONSTRUCTOR:
🞆Constructors are generally used for instantiating an object.
🞆The task of constructors is to initialize(assign values) to the data
members of the class when an object of class is created.
🞆In Python the __init__() method is called the constructor and is
always called when an object is created.
🞆Syntax of constructor declaration :
def __init__(self):
# body of the constructor
🞆 Example: For creating constructor use_ _init_ _ method called as
constructor.

class student:
def __init__(self,rollno,name,age):
self.rollno=rollno
self.name=name
self.age=age
print("student object is created") p1=student(11,"Ajay",20)
print("Roll No of student= ",p1.rollno)
print("Name of student= ",p1.name)
print("Age of student= ",p1.age)
🞆 Output:
student object is created
Roll No of student= 11
Name of student= Ajay
Age of student= 20
🞆 Create a circle class and initialize it with radius. Make two methods
getarea and getcircumference inside this class :

class circle:
def __init__(self,radius):
self.radius=radius
def getarea(self):
return 3.14*self.radius*self.radius
def getcircumference(self):
return 2*3.14*self.radius
c=circle(5)
print("Area=",c.getarea())
print("Circumference=",c.getcircumference())
🞆 Output:
Area= 78.5
Circumference= 31.400000000000002
 TYPES OF CONSTRUCTOR:
There are two types of constructor-
🞆Default constructor- The default constructor is simple
constructor which does not accept any arguments. Its definition
has only one argument which is a reference to the instance being
constructed.

🞆Parameterized constructor- Constructor with parameters is

known as parameterized constructor.
The parameterized constructor take its first argument as a
reference to the instance being constructed known as self and the
rest of the arguments are provided by the programmer
🞆Example: Display Hello message using Default constructor( It
does not accept argument)

class student:
def __init__(self):
print("This is non parameterized constructor")
def show(self,name):
print("Hello",name)
s1=student()
s1.show("World")
🞆Output: This is non parameterized constructor
Hello World
🞆Example: For parameterized constructor
class student:
def __init__(self,name):
print("This is parameterized constructor")
self.name=name
def show(self):
print("Hello",self.name)
s1=student("World")
s1.show()
🞆Output:
This is parameterized constructor
Hello World
 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 memory resources not 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
 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 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()
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 default 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()
 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.
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.
TYPES OF INHERITANCES:

🞆Single Inheritance.
🞆Multiple Inheritance.
🞆Multilevel Inheritance.
🞆Hierarchical Inheritance.
🞆Hybrid Inheritance.
SINGLE INHERITANCE
🞆When child class is derived from only one parent class.
This is called single inheritance.
🞆Syntax:
Class A:
# Properties of class A
Class B(A):
# Class B inheriting property of class A
# more properties of class B
EXAMPLE OF SINGLE INHERITANCE:
# Base class
class Parent:
def func1(self):
print("This function is in parent class.")

# Derived class
class Child(Parent):
def func2(self):
print("This function is in child class.")
object = Child()
object.func1()
object.func2()
🞆 Output:

This function is in parent class.

This function is in child class.
MULTIPLE INHERITANCE
🞆 When child class is derived or inherited from more than one parent
class. This is called multiple inheritance.
🞆 In multiple inheritance, we have two parent classes/base classes and
one child class that inherits both parent classes properties.
🞆 Syntax:

Class A:
# variable of class A
# functions of class A
Class B:
# 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 1 OF MULTIPLE INHERITANCE:
# Base class1 # Derived class
class Mother: class Son(Mother, Father):
def parents(self):
mothername = ""
print("Father :", self.fathername)
def mother(self):
print("Mother :",
print(self.mothername) self.mothername)

# Base class2 # Driver's code

class Father: s1 = Son()
fathername = "" s1.fathername = "RAM"
def father(self): s1.mothername = "SITA"
print(self.fathername) s1.parents()
Output:
Father : RAM
Mother : SITA
 EXAMPLE 2 OF MULTIPLE INHERITANCE:
# Base class1 # Derived class
class Son(Mother, Father):
class Mother:
def parents(self):
mothername = "" print("Father :", self.fathername)
def show(self): print("Mother :", self.mothername)
print(self.mothername)
# Driver's code
s1 = Son()
# Base class2
s1.fathername = "RAM"
class Father: s1.mothername = "SITA"
fathername = "" s1.parents()
def show(self): s1.show()
print(self.fathername) Output:
Father : RAM
Mother : SITA
SITA
 MULTILEVEL INHERITANCE
🞆In multilevel inheritance, we have one parent class and child class
that is derived or inherited from that parent class. We have a grand-
child class that is derived from the child class.
🞆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 OF MULTILEVEL INHERITANCE:
class SuperClass: #create an object of DerivedClass2
d2 = DerivedClass2()
def super_method(self):
print("Super Class method called") d2.super_method()
# Output: "Super Class method called"
class DerivedClass1(SuperClass):
def derived1_method(self): d2.derived1_method()
print("Derived class 1 method # Output: "Derived class 1 method called"
called")

d2.derived2_method()

class DerivedClass2(DerivedClass1): # Output: "Derived class 2 method

called"
def derived2_method(self):
print("Derived class 2 method
called")
HIERARCHICAL INHERITANCE:
🞆When we derive or inherit more than one child class from
one(same) parent class. Then this type of inheritance is called
hierarchical inheritance.
🞆Syntax:
EXAMPLE OF HIERARCHICAL INHERITANCE:
# Base class # Driver's code
class Parent: object1 = Child1()
def func1(self):
object2 = Child2()
print("This function is in parent
class.") object1.func1()
object1.func2()
# Derived class1
class Child1(Parent): object2.func1()
def func2(self): object2.func3()
print("This function is in child
1.")
Output:
This function is in parent class.
# Derivied class2 This function is in child 1.
class Child2(Parent):
def func3(self): This function is in parent class.
print("This function is in child This function is in child 2.
2.")
HYBRID INHERITANCE:
🞆Hybrid inheritance satisfies more than one form of inheritance
i.e. It may be consists of all types of inheritance that we have
done above.
🞆It is not wrong if we say Hybrid Inheritance is the
combinations of simple, multiple, multilevel and hierarchical
inheritance.
class School:
def func1(self):
print("This function is in school.")

class Student1(School):
def func2(self):
print("This function is in student 1. ")

class Student2(School):
def func3(self):
print("This function is in student 2.")

class Student3(Student1, School):

def func4(self):
print("This function is in student 3.")

# Driver's code
object = Student3()
object.func1()
object.func2()

Output:
This function is in school.
This function is in student 1.
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 calls overridden 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 calls overridden method
🞆Output:
This is base class
This is derived class
What is Composition (Has-A Relation)
● It is one of the fundamental concepts of Object-Oriented Programming. In this
concept, we will describe a class that references to one or more objects of
other classes as an Instance variable.
● Here, by using the class name or by creating the object we can access the
members of one class inside another class.
● It enables creating complex types by combining objects of different classes. It
means that a class Composite can contain an object of another class
Component.
● This type of relationship is known as Has-A Relation
SYNTAX:
class A :
# variables of class A
# methods of class A
...
...

class B :
# by using "obj" we can access members of class A.
obj = A()

# variables of class B
# methods of class B

...
...
class Component:
# composite class constructor
def __init__(self):
print('Component class object created...')
# composite class instance method
def m1(self):
print('Component class m1() method executed...')
class Composite:
# composite class constructor
def __init__(self):
# creating object of component class
self.obj1 = Component()
print('Composite class object also created...')
# composite class instance method
def m2(self):
print('Composite class m2() method executed...')
# calling m1() method of component class
self.obj1.m1()
# creating object of composite class
obj2 = Composite()
# calling m2() method of composite class
OUTPUT:
🞆 Component class object created...
🞆 Composite class object also created...
🞆 Composite class m2() method executed...
🞆 Component class m1() method executed...
🞆 In the above example, we created two classes Composite and Component
to show the Has-A Relation among them.
🞆 In the Component class, we have one constructor and an instance method
m1().
🞆 Similarly, in Composite class, we have one constructor in which we created
an object of Component Class. Whenever we create an object of Composite
Class, the object of the Component class is automatically created.
🞆 Now in m2() method of Composite class we are calling m1() method of
Component Class using instance variable obj1 in which reference of
Component Class is stored.
🞆 Now, whenever we call m2() method of Composite Class, automatically m1()
method of Component Class will be called.
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
🞆 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.