Object Oriented Programming(OOP)

OOP allows to decompose a program into number of entities called objects

and build data and functions around these objects.
Python is an object oriented programming language. It allows us to develop
applications using object oriented approach.
OOP features:
Object
Class
Inheritance
Polymorphism
Data abstraction
Encapsulation

Object: - Object is an entity that has state and behavior. It may be anything.
Everything in Python is an object, and almost everything has attributes and
methods.
Class: - 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 employee class then it should contain an
attribute and method that is a name, age, emailid, salary etc.
Syntax:
class <classname>:
-----------
-----------
Inheritance: - It specifies that one object acquires all the properties and
behaviors of parent object. By using inheritance we can define a new class
with a little or no changes to the existing class. The new class is known as
derived class or child class and from which it inherits the properties is called
base class or parent class.
Polymorphism: - Polymorphism made by two words “poly” and “morphs”.
Poly means many and morphs means forms. It defines that one task can be
performed in different ways.

1
Encapsulation: - It is used to restrict access to methods and variables. In
encapsulation, code and data wrapped together within a single unit.
Data abstraction: - Abstraction is used to hide internal details and show only
functionalities.

Difference between object oriented and procedural oriented

Object oriented Procedural oriented
Object oriented programming is an Procedural programming uses a list
problem solving approach and used of instructions to do computation step
where computation is done by using by step.
objects.

It makes development and It is not easy to maintain the codes

maintenance easier. when project become lengthy.

It simulates the real world entity. So It does not simulate the real world. It
real world problems can be easily works on step-by-step instructions
solved through OOPs. divided into small parts called
functions.

It provides data hiding. So it is more It does not provide any proper way
secure than procedural languages. for data hiding, so it is less secure.

Ex: C++, Java, .Net, Python …. Ex: C, Fortran, Pascal…

2
Class: -
→In Python everything is an object. To create objects, we required some
Model or Plan or Blueprint, which is nothing but class.
→We can write a class to represent properties(attributes) and actions
(behavior) of object.
→Properties can be represented by variables.
→Actions can be represented by methods.
→Hence class contains both variables and methods.
How to define a class?
We can define a class by using class keyword.
Syntax:
class <classname>:
'''documentation string'''
Variables: instance variables, static and local variables
methods: instance methods, static methods and class methods
→Documentation string represents description of the class. Within the class
doc string is always optional. We can get doc string by using the following 2
ways.
print(classname.__doc__)
help(classname)

Ex:
class Student:
"This is Student class with required data"
print(Student.__doc__)

What is Object:
Physical existence of a class is nothing but object. We can create any number
of objects for a class.

3
Create an object in Python:
We can create a new object instance of the class. The procedure to
create an object is similar to function call.
Syntax:
referencevariable=classname() Ex:
Ob1=MyClass()

What is reference variable?

The variable which can be used to refer object is called reference variable.
By using reference variable, we can access properties and methods of object.
Ex: class MyClass:
"This is class cocept"
a=50
def func(self):
print("This is
function") ob=MyClass()
print(ob.__doc__) print(ob.a)
ob.func()

self variable:
→ Class methods have only one specific difference from ordinary functions -
they must have an extra argument in the beginning of the parameter list.
→self is a reference variable which is always pointing to current object. →By
using self we can access instance variables and instance methods of object.
Ex:
class Student: def
show(self):
print(id(self))

s1=Student() s1.show()
s2=Student() s2.show()
→For these reasons,
the first argument of

4
the constructor and
instance method in
class must be self.
→PVM is responsible to provide value for self argument and we are not
required to provide explicitly.
→By using self we can declare instance variables.
→By using self we can access instance methods.
→Instead of self we can use any name, but recommended to use.
Ex :
class Myclass():
def m1(self): print("m1
function")
def m2(self): print("m2
function")
c = Myclass() c.m1()
c.m2()

Ex: Accept two numbers and display that numbers.

class Sample: def getdata(self,a,b):
self.a=a
self.b=b def
show(self):
print("a=",self.a,"b=",self.b)

ob=Sample()
ob.getdata(10,20) ob.show()
Constructors: -

A constructor is a special type of method (function) which is used to initialize

the instance members of the class. It automatically initializes when an object
is created. Constructor can be parameterized or non-parameterized.
Creating a constructor:
→A constructor is a class method that begins with double underscore (__).
The name of the constructor is always the same as __init__(self).
5
 Ex: def __init__(self):
→Whenever we are creating an object constructor will be executed
automatically and we are not required to call explicitly.
→The main objective is to declare and initialize variables.
→For every object constructor will be executed only once.
→While creating an object, a constructor can accept arguments if necessary.
When we create a class without a constructor, Python automatically creates a
default constructor that doesn’t do anything.
→If our class does not have any constructor then Python follows below
execution.

Ex:
class MyClass:
def __init__(self):
print("constructor")
a = MyClass()

Ex:
class MyClass:
a,b=100,200 def
__init__(self,a,b):
print(a+b)
print(self.a+self.b)
c = MyClass(10,20)

Inheritance:
→It is used to create a new class based on existing class. The new class
acquires the properties of parent class and adds its own.
→The new class is called as child class or derived class and the existing class
is called as parent class or base class.
→Whatever variables, methods available in the parent class by default
available to the child class and we are not required to rewrite. Hence the main

6
advantage of inheritance is code reusability and we can extend existing
functionality with more extra functionality.
Syntax:
class <newclassname> (<existingclass>):

Ex:
class P:
a=10 def
__init__(self):
self.b=10
def m1(self):
print("Parent class instance method")
@classmethod
def m2(cls):
print("Parent class class method")
@staticmethod
def m3():
print("Parent class static method")

class C(P):pass

c=C() print(c.a)
print(c.b)
c.m1()
c.m2()
c.m3()
→Whatever members in parent class are by default available to the child class
through inheritance.
Ex:
class P: def
m1(self):
print("Parent class method")
class C(P):

7
 def m2(self):
print("Child class method")

c=C()
c.m1()
c.m2()

Types of inheritance:
1. Single inheritance.
2. Multilevel inheritance.
3. Hierarchical inheritance.
4. Multiple inheritance.
5. Hybrid inheritance.
6. Cyclic inheritance.

Single inheritance: - A base class has only one derived class is called as
single inheritance.

B
Ex:-
class Parent:
def speak(self):
return "Speaking from Parent"

class Child(Parent):
def speak(self):
return "Speaking from Child"

c = Child()
print(c.speak())

Multilevel inheritance: - A derived class which can be inherited from another

derived class is called as multilevel inheritance.

8
 A

C
Ex:-
class Grandparent:
def greet(self):
return "Hello from Grandparent"

class Parent(Grandparent):
pass

class Child(Parent):
pass

c = Child()
print(c.greet()) # Output: Hello from Grandparent

Hierarchical inheritance: - A base class which has more than one derived
class is called as hierarchical inheritance.

B C
Ex:-
class Parent:
def greet(self):
return "Hello from Parent"

class Child1(Parent):
pass

class Child2(Parent):
pass

c1 = Child1()
c2 = Child2()
print(c1.greet()) # Output: Hello from Parent
print(c2.greet()) # Output: Hello from Parent

9
Multiple inheritance: - A derived class have more than one base class is
called as multiple inheritance.

A B

C
Ex:-
class Parent1:
def greet(self):
return "Hello from Parent1"

class Parent2:
def greet(self):
return "Hello from Parent2"

class Child(Parent1, Parent2):

pass

c = Child()
print(c.greet()) # Output: Hello from
Parent1 (Python chooses Parent1 first)

Hybrid inheritance: - Combination of two or more inheritance is called as

hybrid inheritance.

B C

D
Ex:-
class Base:
def greet(self):
return "Hello from Base"

class Parent1(Base):
pass
10
 class Parent2(Base):
pass

class Child(Parent1, Parent2):

pass

c = Child()
print(c.greet()) # Output: Hello from Base

Cyclic inheritance: - If a class extends same class is called cyclic

inheritance. Python won’t support for cyclic inheritance.

Ex:
class A(A):
-------
Ex: class A(B):
-------
class B(A):
-------
super() Function:-
The super() function calls a
method from the parent
class.
Ex:-
class Parent:
def greet(self):
return "Hello from
Parent"

class Child(Parent):
11
 def greet(self):
parent_greeting =
super().greet() # Calls
Parent's greet
return
parent_greeting + " and
Hello from Child"

c = Child()
print(c.greet()) # Output:
Hello from Parent and
Hello from Child

12
Abstract Class:
A class which contains one or more abstract methods is called an abstract
class. An abstract method is a method that has a declaration but does not
have an implementation.
How Abstract Base classes work :
By default, Python does not provide abstract classes. Python comes with a
module which provides the base for defining Abstract Base class(ABC) and
that module name is abc. ABC works by decorating methods of the base class
as abstract and then registering concrete classes as implementations of the
abstract base. A method becomes abstract when decorated with the

@abstractmethod.

Abstract Method:
→Sometimes we don’t know implementation, still we can declare a method.
Such type of methods are called abstract methods.i.e abstract method has
only declaration but not implementation.
→In Python we can declare abstract method by using @abstractmethod
decorator as follows:
@abstractmethod
def m1(self):pass
→@abstractmethod decorator present in abc module. Hence compulsory we
should import abc module, otherwise we will get error.
→abc=abstract base class module.

→Child classes are responsible to provide implementation for parent class

abstract methods.

Ex:
from abc import ABC, abstractmethod

class Animal(ABC):
@abstractmethod
def sound(self):
13
 pass

class Dog(Animal):
def sound(self):
return "Woof!"

d = Dog()
print(d.sound()) # Output: Woof!
Interfaces
→In general if an abstract class contains only abstract methods such type of
abstract class is considered as interface.

Concrete class vs Abstract class vs Interface:

→If we don’t know anything about implementation just we have requirement
specification then we should go for interface.
→If we are talking about implementation but not completely then we should go
for abstract class.
→If we are talking about implementation completely and ready to provide
service then we should go for concrete class.
Ex: from abc import *
class CollegeAutomation(ABC):
@abstractmethod
def m1(self):pass
@abstractmethod
def m2(self):pass
@abstractmethod
def m3(self):pass class
AbsCls(CollegeAutomation)
: def m1(self):
print("m1 method implementation")
def m21(self):

14
 print("m2 method
implementation") class ConcreteCls(AbsCls):
def m3(self):
print("m3 method implementation")

c=ConcreteCls() c.m1()
c.m2()
c.m3()

Exception Handling:
In any programming language there are two types of errors are possible:
Syntax errors
Runtime errors
Syntax errors: - The errors which occur because of invalid syntax are called
syntax errors.
Ex:
x=10 if
x==10
print("Hello")
SyntaxError: Invalid syntax
Ex: print "Hello"
SyntaxError: Missing parantheses in call to ‘print’
Note: - Programmer is responsible to correct these syntax errors. Once all
syntax errors are corrected then only program execution will be started.
Runtime errors: - →Also
known as exceptions.
→While executing the program if something goes wrong because of end user
input or programming logic or memory problems etc then we will get runtime
errors.
Ex1:
print(10/0) → ZeroDivisionError:division by zero Ex2:

15
print(10/"ten") →TypeError: unsupported operand type(s) for /: ‘int’ and ‘str’
Ex3: x=int(input("Enter number:") print(x)
→At runtime if you enter ten then following exception will be raised.
ValueError: Invalid literal for int() with base 10:’ten’
Note: - Exception handling concept applicable for runtime errors but not for
syntax errors.

Exception: -An unwanted and unexpected event that disturbs normal flow of
the program is called exception.
Ex:
a=10/0
print(a)
print("Satish software solutions") To
run the file:
a=10/0
ZeroDivisionError: division by zero
→It is highly recommended to handle exceptions. The main objective of
exception handling is graceful (normal) termination of the program.
→Exception handling does not mean repairing exception. We have to define
alternative way to continue rest of the program normally.

Default exception handling in Python:

→Every exception in Python is an object. For every exception type, the
corresponding classes are available.
→Whenever an exception occurs PVM will create the corresponding exception
object and will check for handling code. If handling code is not available then
Python interpreter terminates the program abnormally and prints
corresponding exception information to the console.
→The rest of the program won’t be executed. Ex:
print("Hello")
print(10/0)

16
 print("Satish software solutions") To
run the file:
Hello
Traceback (most recent call last):
File "test.py", line 2, in <module>
print(10/0)
ZeroDivisionError: division by zero

Customized exception handling by using try-except:

The code which may raise exception is called risky code and we have to take
risky code inside try block. The corresponding handling code we have to take
inside except block.
Syntax: try:
exceptional code
except Exception1: execute code if
exception raised
except Exception2:
execute code if exception raised
....
.... except
ExceptionN:
execute code if exception raised
except : code execute if other except blocks are not
matched. else:
In case of no exception, execute the else block code.

Ex :
print("Satatement1")
try:
n = int(input("enter a number:"))
print(10/n)
except ZeroDivisionError as e:
print(f “Error: {e}")

17
Ex: except block is not matched so program terminated abnormally
print("Satatement1") try:
n = int(input("enter a number:"))
print(10/n)
except TypeError: print(10/2)
print("rest of the app")

finally block: -
→It is never recommended to maintain clean up code (Resource deallocating
code or resource releasing code) inside try block because there is no
guarantee for the execution of every statement inside a try.
→It is never recommended to maintain clean up code inside except block
because if there is no exception then except block won’t be executed.
→Hence we required some place to maintain clean up code which should be
executed always irrespective of whether exception raised or not raised and
whether handled or not handled such type of place is nothing but finally block.
→Hence the main purpose of finally block is to maintain cleanup code.

Syntax: try:
<exceptional code> except
<ExceptionType1>:
<handler1> except
<ExceptionTypeN>:
<handlerN> except:
<handlerExcept> else:
<process_else> finally:
<process_finally>

Ex: try:
a=10/2 print(a)
except:

18
 print("Second
no cannot be
zero") finally:
print("Code to be executed")

Ex: try:
a=10/0
print("Exception")
except ZeroDivisionError:
print("Second no cannot be zero")
finally:
print("Code to be executed")

Ex: try:
a=10/0
print("Exception")
except IndexError:
print("Second no cannot be zero")
finally:
print("Code to be executed")

Types of exceptions:
1. Pre-defined exceptions / Built-in Exceptions
2. User defined exceptions / Customized exceptions
Pre-defined exceptions: - The exceptions which are raised automatically by
Python Virtual Machine whenever a particular event occurs, such type of
exceptions are called pre-defined exceptions.
Ex:
print(10/0)
ZeroDivisionError
int("ten")
ValueError

19
User defined exceptions: - Sometimes we can create our own exception to
meet our programming requirements, such type of exceptions are called
customized exceptions.
→ By using raise keyword, we can raise predefined exceptions & user defined

exceptions.
→ By using raise keyword it is not recommended to raise predefined

exceptions because predefined exceptions contains some fixed

meaning(don’t disturb the meaning).
raise ArithmeticError("name is not good")
→ By using raise keyword it is recommended to raise user defined
exceptions.
raise InvalidAgeError("age is not good")

raise keyword :
→ To raise your exceptions from your own methods you need to use raise

keyword.
raise ExceptionClassName("Your information")

User defined exceptions :

Ex:
class YoungException(Exception):
def __init__(self,arg):
self.msg=arg
class OldException(Exception):
def __init__(self,arg):
self.msg=arg

age=int(input("Enter age:"))
if age<21:
raise YoungException("Please wait u have more time")
elif age>60:
raise OldException("Your age crossed")

20
else:
print("Thanks for registering")

21