ISBM College of Engineering, Department of AIML

Programming and Problem Solving

Notes:-Unit-5
Course: FE, A Div & B Div

Unit V
Object Oriented Programming
Programming Paradigms-monolithic, procedural, structured and object oriented, Features of
Object oriented programming-classes, objects, methods and message passing, inheritance,
polymorphism, containership, reusability, delegation, data abstraction and encapsulation.

Classes and Objects: classes and objects, class method and self object, class variables and object
variables, public and private members, class methods.
Programming Paradigms:

Monolithic:
A monolithic programming paradigm refers to a software architecture in which all components of
the system are combined into a single, unified executable. This is in contrast to other architectural
styles such as microservices, where the system is broken down into smaller, independently
deployable components. Monolithic architectures are simpler to develop and maintain, but can
become unwieldy as the system grows in complexity and scale.
An example of a monolithic architecture would be a traditional 3-tier web application. The
application would have a single codebase containing all the layers: the user interface, the business
logic, and the data storage. All the components are tightly coupled and interact with each other
through a single process. All the code is executed in a single process and the entire application is
deployed as a single unit.

For example, a monolithic e-commerce application would have all the code for the user interface,
product catalog, shopping cart, and order management in a single codebase and would be deployed
as a single unit. This can make it difficult to scale, update or maintain the application as it grows in
complexity.

Another example of a monolithic architecture is a desktop application. A monolithic desktop

application would have all the code for the user interface, business logic, and data storage in a
single executable file. All the components are tightly coupled and interact with each other through
a single process. For example, a monolithic image editing software would have all the code for the
user interface, image editing tools, and file management in a single executable file. This can make it
difficult to add new features or update certain parts of the application without affecting the entire
application.

Here are some examples of monolithic software applications:

1. Traditional 3-tier web applications: These are applications where all the layers of the system
(user interface, business logic, and data storage) are combined into a single codebase and
deployed as a single unit.

2. Desktop applications: These are applications where all the code for the user interface,
business logic, and data storage are combined into a single executable file.

1 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

3. Embedded systems: These are applications where all the code for the user interface,
hardware control, and data storage are combined into a single unit.

4. Gaming engines: These are applications where all the code for the game engine, physics,
and graphics are combined into a single unit.

5. Enterprise resource planning (ERP) systems: These are applications where all the code for
the different business modules such as finance, inventory, and human resources are
combined into a single unit.

6. CRM systems: These are applications where all the code for the different business modules
such as sales, marketing, and customer support are combined into a single unit.

Procedural programming:

Procedural programming is a programming paradigm that emphasizes the use of procedures or

functions to perform operations on data. In procedural programming, the program is organized as a
series of procedures, each of which performs a specific task. The procedures are typically organized
in a hierarchical manner, with higher-level procedures calling lower-level procedures to perform
more specific tasks.

In procedural programming, the focus is on the procedures themselves, rather than on the data
that the procedures operate on. Programs are written as a series of instructions, in which the
computer follows a set of steps in a linear, sequential manner. Programs are often structured as a
series of procedures, each of which performs a specific task.

Examples of programming languages that support procedural programming include C, Pascal, and
Fortran.

It's worth noting that procedural programming is still widely used today, and it's considered as one
of the traditional programming paradigm, and it's not limited to these old languages. Many modern
programming languages, such as C#, C++ and Java, have support for procedural programming and
it's used in many domains.

Structured programming:

Structured programming is a programming paradigm that emphasizes the use of well-defined

structures, such as functions and control flow statements, to organize a program. The goal of
structured programming is to make code more readable, maintainable, and less prone to errors.

In structured programming, control flow statements like if-else, for-loops and while-loops are used
to direct the flow of execution through the program. Functions and procedures are used to group
related code into logical units that can be easily reused and tested.

2 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

Structured programming builds on top of the procedural programming paradigm and it's considered
as a subset of it. It's an approach that enforces a logical and clear structure in the program and it's
advocated to make the program more understandable and easy to maintain.

Examples of programming languages that support structured programming include C, Pascal, and
Fortran, and like procedural programming, many modern programming languages, such as C#, C++
and Java, have support for structured programming and it's widely used in many domains.

Object oriented programming:

Object-oriented programming (OOP) is a programming paradigm that is based on the concept of

"objects", which are instances of classes that encapsulate data and behavior. In OOP, a class is a
blueprint for creating objects (a particular data structure), providing initial values for state (member
variables or attributes), and implementations of behavior (member functions or methods).

OOP is characterized by several key concepts, including encapsulation, inheritance, and

polymorphism.

 Encapsulation: The idea of encapsulation is to group related data and behavior together
within an object, and hide the implementation details from the outside world. This allows
for data and behavior to be protected from accidental modification and ensures that the
implementation can be changed without affecting the rest of the program.

 Inheritance: Inheritance allows for one class to inherit the properties and methods of
another class. This allows for code reuse and a clear hierarchy of classes in the program.

 Polymorphism: Polymorphism allows for a single function or method to operate on multiple

different types of objects, based on the type of object that it is called on. This allows for
code to be written in a more general way, making it more reusable.

Examples of programming languages that support object-oriented programming include Java, C++,
C#, Python, and Ruby, and it's widely used in many domains such as web development, game
development, and enterprise software development.

Difference between structured and procedural

Structured programming and procedural programming are similar in that both are programming
paradigms that emphasize the use of procedures and control flow statements to organize a
program. However, there are some key differences between the two:

 Structured programming is considered to be a subset of procedural programming, it builds

on top of it, and it's more focused on the organization of the code. Structured programming
emphasizes the use of well-defined structures, such as functions and control flow
statements, to make the code more readable, maintainable, and less prone to errors.

3 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

 Procedural programming is more focused on the procedures themselves, rather than on the
data that the procedures operate on. Programs are written as a series of instructions, in
which the computer follows a set of steps in a linear, sequential manner.

 Structured programming enforces a logical and clear structure in the program and it's
advocated to make the program more understandable and easy to maintain.

 In procedural programming, the focus is on the procedures themselves, rather than on the
data that the procedures operate on. Programs are written as a series of instructions, in
which the computer follows a set of steps in a linear, sequential manner.

It's worth noting that both paradigms are still widely used today, and many modern programming
languages have support for both procedural and structured programming. However, OOP paradigm
is considered as more modern and widely used among new development projects.

Here are the key differences between structured and procedural programming, summarized in a
point-wise format:

Structured Programming:

 Emphasizes the use of well-defined structures, such as functions and control flow
statements, to organize a program.

 Focuses on the organization of the code and making it more readable, maintainable, and
less prone to errors.

 Enforces a logical and clear structure in the program

 Considered to be a subset of procedural programming

Procedural Programming:

 Focuses on the procedures themselves, rather than on the data that the procedures operate
on.

 Programs are written as a series of instructions, in which the computer follows a set of steps
in a linear, sequential manner.

 The focus is on the procedures themselves, rather than on the data that the procedures
operate on.

 Considered as more "procedure-oriented" paradigm in comparison to structured

programming.

4 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

Part-1: Classes, objects, methods and message passing, inheritance, polymorphism,

containership, reusability, delegation, data abstraction and encapsulation:

Classes: A blueprint for creating objects (a particular data structure), providing initial values for
state (member variables or attributes), and implementations of behavior (member functions or
methods).

Objects: An instance of a class. It has the state and behavior defined by the class.

Methods: Functions that belong to a class and operate on objects of that class.

Message passing: The process of sending a request to an object, triggering the execution of one of
its methods. In object-oriented programming, it is the mechanism of communicating between
objects, allowing objects to send and receive messages.

Inheritance: A mechanism that allows a new class to inherit properties and behavior from an
existing class, creating a hierarchy of classes that can share attributes and methods. In Python, a
subclass can inherit from a superclass using the syntax "class SubClass(SuperClass):".

Polymorphism: The ability of objects belonging to different classes to be used interchangeably in

the same context, because they all respond to the same method calls. In Python, polymorphism is
achieved through method overloading, method overriding, and duck typing.

Containership:

"Containership" in Python refers to the concept of containerization. This is the process of packaging
code and its dependencies into a single unit, called a container ,that can be run in any environment
without changes. The main goal of containerization is to ensure that an application works
consistently across different environments and systems, making it easier to deploy, test, and
manage.

The most popular tool for containerizing applications in Python is Docker. With Docker, you can
create a Docker image of your application, which includes everything that your code needs to run,
such as libraries, runtime environment, and other dependencies. Docker images can then be run as
containers on any system that has Docker installed, making it easy to deploy and run your
application in different environments.

Docker is a popular tool for containerizing applications, and it can be used with Python as well. With
Docker, you can package your Python application and its dependencies into a single unit, called a
Docker image, which can be run in any environment without changes. This makes it easier to
deploy, test, and manage your application in different environments.

Here's a basic example of how you can use Docker with Python:

5 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

1. Write your Python code and specify its dependencies in a requirements.txt file.

2. Create a Dockerfile that defines the environment in which your Python application will run.
This includes the base image, such as a lightweight Linux distribution, and the installation of
the necessary packages and dependencies.

3. Build your Docker image by running the following command in the terminal:

docker build -t my-python-app

4. Once the image is built, you can run it as a container using the following command:

docker run -p 4000:80 my-python-app

This will run your Python application inside a container and map port 4000 on your host to port 80
in the container.

Containment or Composition: A relationship between two classes where one class contains the
other class as a member. The contained class is referred to as a member object. In Python,
containment can be implemented using instance variables that hold reference to other objects.

Reusability: The ability to use code written for a class in multiple projects, reducing the need to
rewrite the same code. In Python, reusability is achieved through inheritance, encapsulation, and
abstraction.

Delegation: A relationship between two classes where one class delegates a task to another class.
In Python, delegation can be implemented by calling methods of another class from within a
method of the delegating class.

Delegation is a design pattern that involves creating a wrapper class that delegates method calls to
an underlying object. This can be useful in a variety of situations, including implementing proxies,
adding functionality to existing objects, or creating composable objects.

A design pattern is a general repeatable solution to a commonly occurring problem in software

design. It is a template or blueprint for solving a problem that can be used in many different
situations. Design patterns can speed up the development process by providing tested, proven
development paradigms.

There are several types of design patterns, including:

1. Creational patterns: focus on object creation mechanisms, trying to create objects in a

manner suitable to the situation.

2. Structural patterns: concern class and object composition. Structural class-level patterns use
inheritance to compose interfaces or implementations.

6 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

3. Behavioral patterns: focus on communication between objects, what goes on between

objects and how they operate together.

4. Concurrency patterns: deal with multi-threaded programming paradigms.

5. Architectural patterns: deal with large-scale software architecture and high-level design
structures that address various issues such as security, performance, scalability, and
maintainability.

Examples of popular design patterns include Singleton, Factory Method, Observer, Decorator, and
MVC (Model-View-Controller).

Data Abstraction: The process of hiding the implementation details of a class from the user, and
presenting only the necessary information. In Python, data abstraction can be achieved through
encapsulation and the use of accessor and mutator methods (getters and setters).

Encapsulation: The process of wrapping data and functions that manipulate that data within a
single unit, or object. In Python, encapsulation is achieved through the use of classes, which define
objects that contain both data and behavior.

Part-2: classes and objects, class method and self object, class variables and object
variables, public and private members, class methods.

Classes and Objects: A class is a blueprint for creating objects, which are instances of the class.
Classes define the properties and behavior of objects, while objects represent unique instances of
the class. In Python, a class is defined using the keyword "class".

 Class: The class is a user-defined data structure that binds the data members and methods
into a single unit. Class is a blueprint or code template for object creation. Using a class,
you can create as many objects as you want.

 Object: An object is an instance of a class. It is a collection of attributes (variables) and

methods. We use the object of a class to perform actions.

Define a class in Python

In this example, we are creating a Person Class with name, sex, and profession instance
variables.

class Person:
def __init__(self, name, gender, profession):
# data members (instance/object variables)
self.name = name
self. gender = gender

7 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

self.profession = profession

# Behavior (instance methods)

def show(self):
print('Name:', self.name, ' Gender:', self. gender, 'Profession:', self.profession)

# Behavior (instance methods)

def work(self):
print(self.name, 'working as a', self.profession)
Create Object of a Class:
An object is essential to work with the class attributes. The object is created using the class
name. When we create an object of the class, it is called instantiation. The object is also
called the instance of a class.
A constructor is a special method used to create and initialize an object of a class. This
method is defined in the class.

In Python, Object creation is divided into two parts in Object Creation and Object
initialization

 Internally, the __new__ is the method that creates the object

 And, using the __init__() method we can implement constructor to initialize the
object.

# create object of a class

p1 = Person('Shriram', 'Female', 'Software Engineer')
# call methods
P1.show()
P1.work()

Output:
Name: Shriram Gender: Female Profession: Software Engineer
Shriram working as a Software Engineer

Constructor:

A constructor is a special method that is called when an object is created. It is used to initialize the
object and set its initial state. In Python, the constructor method is called __init__().
There are two types of constructors in Python:
1. Default constructor: A default constructor is a constructor that doesn't take any arguments.
It is automatically called when an object is created. It doesn't do anything by default, but
you can define your own default constructor if you need to initialize some attributes with
default values.

8 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

Example of a default constructor:

class MyClass:
def __init__(self):
self.my_attribute = 0

2. Parameterized constructor: A parameterized constructor is a constructor that takes one or

more arguments. It is used to initialize the object with specific values.
Example of a parameterized constructor:
class Car:
def __init__(self, make, model, year):
self.make = make
self.model = model
self.year = year

The benefits of using constructors in Python are:

1. They ensure that an object is properly initialized with the required attributes.
2. They make it easy to set default values for attributes.
3. They help to reduce duplicate code by allowing you to define common initialization logic in
one place.
4. They provide a way to ensure that attributes are set with valid values before the object is
used.
5. They make it easy to create multiple instances of a class with different initial values.
Use of self Paramenter:
Self is a special parameter that is used inside class methods to refer to the instance of the class.
When you call a method on an instance of a class, Python automatically passes a reference to that
instance as the first argument to the method, and this reference is assigned to the self parameter.
The self parameter allows you to access the attributes and methods of the current instance of the
class. For example, you can use self to set and get the values of the instance variables, call other
methods on the instance, or even create new attributes or methods dynamically.

Class Attributes:
When we design a class, we use instance variables and class variables.
In Class, attributes can be defined into two parts:
 Instance variables: The instance variables are attributes attached to an instance of a
class. We define instance variables in the constructor ( the __init__() method of a
class).
 Class Variables: A class variable is a variable that is declared inside of class, but outside
of any instance method or __init__() method.

Objects do not share instance attributes. Instead, every object has its copy of the instance
attribute and is unique to each object.

9 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

All instances of a class share the class variables. However, unlike instance variables, the value
of a class variable is not varied from object to object.

Only one copy of the static variable will be created and shared between all objects of the
class.

Create Class Variables

A class variable is declared inside of class, but outside of any instance method
or __init__() method.

By convention, typically it is placed right below the class header and before the constructor
method and other methods.

class Student:
# Class variable
school_name = 'ABC School '

def __init__(self, name, roll_no):

self.name = name
self.roll_no = roll_no

# create first object

s1 = Student('Emma', 10)
print(s1.name, s1.roll_no, Student.school_name)
# access class variable

# create second object

s2 = Student('Jessa', 20)
# access class variable
print(s2.name, s2.roll_no, Student.school_name)

Output:
Emma 10 ABC School
Jessa 20 ABC School

List the differences between class variables and object variables python:

Class variables and object variables in Python are used to store data associated with classes
and objects, respectively. Here are the main differences between the two:

10 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

1. Scope: Class variables are defined inside a class and are shared by all instances
(objects) of the class. Object variables, on the other hand, are unique to each object
and are only accessible through that particular object.
2. Declaration: Class variables are declared using the "class" keyword, whereas object
variables are created for each object by using the "self" keyword within a class
method.
3. Initialization: Class variables are typically initialized within the class definition,
whereas object variables are usually initialized within a method of the class and can
have different values for different objects.
4. Modification: Class variables can be modified by any instance of the class and the
change will be reflected in all other instances. Object variables can only be modified
through the specific object they belong to.
5. Purpose: Class variables are used to store information that is common to all objects
of a class, while object variables are used to store information that is specific to each
individual object.

Class Variables and Object Variables: Class variables are shared among all instances of a
class and are defined within the class, but outside of any method. Object variables are unique
to each instance of a class and are defined within methods.

Class Methods:

In Object-oriented programming, we use instance methods and class methods. Inside a

Class, we can define the following three types of methods.

 Instance method: Used to access or modify the object state. If we use instance
variables inside a method, such methods are called instance methods. It must have
a self parameter to refer to the current object.

 Class method: Used to access or modify the class state. In method implementation, if
we use only class variables, then such type of methods we should declare as a class
method. The class method has a cls parameter which refers to the class.

 Static method: It is a general utility method that performs a task in isolation. Inside
this method, we don’t use instance or class variable because this static method
doesn’t take any parameters like self and cls.

Example: Instance Method:

 Instance methods are methods that are defined inside a class and are called on an
instance of that class. These methods have access to the instance variables of the
class, which means they can operate on the state of the object.

11 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

 Instance methods are defined using the def keyword and take self as the first
argument, which refers to the instance of the class on which the method is called.
The self argument allows the instance method to access and modify the instance
variables of the class.

class Person:
def __init__(self, name, age):
self.name = name
self.age = age

def say_hello(self):
print("Hello, my name is", self.name, "and I am", self.age, "years old.")

In this example, we have defined a class called Person with two instance variables name and
age. We have also defined an instance method called say_hello() which takes self as the first
argument and prints a message that includes the name and age of the person.
To create an object of this class and call the say_hello() method, we can do the following:

p = Person("Shriram", 25)
p.say_hello()

Example: Class Method

Class methods are methods that are bound to the class and not the instance of the class.
They can be called on the class itself or any instance of the class. Class methods are defined
using the @classmethod decorator and take the class as the first argument, conventionally
named cls.

Example1:

class Person:
count = 0

def __init__(self, name, age):

self.name = name
self.age = age
Person.count += 1

@classmethod
def get_count(cls):
return cls.count

12 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

In this example, we have defined a class called Person with two instance variables name and
age, and a class variable count. The __init__() method initializes the name and age instance
variables and increments the count class variable by 1 for each new instance of the class.
We have also defined a class method called get_count() which takes the class as the first
argument, conventionally named cls, and returns the value of the count class variable.
To call the get_count() method on the Person class, we can do the following:
print(Person.get_count())
This will print the value of the count class variable, which is the total number of instances of
the Person class that have been created. We can also call the get_count() method on any
instance of the Person class, like this:
p1 = Person("Alice", 25)
p2 = Person("Bob", 30)
print(p1.get_count())
print(p2.get_count())

This will print the same value of the count class variable for both instances, which is the total
number of instances of the Person class that have been created.

Example 2:
from datetime import date

class Student:
def __init__(self, name, age):
self.name = name
self.age = age

@classmethod
def calculate_age(cls, name, birth_year):
# calculate age an set it as a age
# return new object
return cls(name, date.today().year - birth_year)

def show(self):
print(self.name + "'s age is: " + str(self.age))

obj1 = Student('Shriram', 60)

obj1.show()

# create new object using the factory method

obj2 = Student.calculate_age("Ajay", 1995)
obj2.show()
13 Prof. K.N. Tripathi
 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

Class Method and Self Object: The "self" object is a reference to the instance of a class. It is used to
access the attributes and methods of the class. A class method is a method that is bound to the
class and not the instance of the class. It is defined using the "@classmethod" decorator.

Public and private members:

Public and Private Members: In Python, members with a double underscore prefix (e.g. "__private")
are considered private and are not accessible from outside the class. Members without the prefix
(e.g. "public") are considered public and are accessible from outside the class.

A Class in Python has three types of access modifiers:

 Public Access Modifier
 Protected Access Modifier
 Private Access Modifier

Public Access Modifier:

The members of a class that are declared public are easily accessible from any part of the
program. All data members and member functions of a class are public by default.

# Program to illustrate public access modifier in a class

class Student:

# constructor
def __init__(self, name, age):

# public data members

self.studentName = name
self.studentAge = age

# public member function

def displayAge(self):

# accessing public data member

print("Age: ", self.studentAge)

# creating object of the class

obj = Student("AJAY", 20)

# accessing public data member

print("Name: ", obj.studentName)

# calling public member function of the class

14 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

obj.displayAge()

Output:
AJAY
20
Protected Access Modifier:
The members of a class that are declared protected are only accessible to a class derived
from it. Data members of a class are declared protected by adding a single underscore ‘_’
symbol before the data member of that class.

# Program to illustrate protected access modifier in a class

# super class
class Student:

# protected data members

_name = None
_roll = None
_branch = None

# constructor
def __init__(self, name, roll, branch):
self._name = name
self._roll = roll
self._branch = branch

# protected member function

def _displayRollAndBranch(self):

# accessing protected data members

print("Roll: ", self._roll)
print("Branch: ", self._branch)

# derived class
class Student(Student):

# constructor
def __init__(self, name, roll, branch):
Student.__init__(self, name, roll, branch)

# public member function

def displayDetails(self):

# accessing protected data members of super

class
print("Name: ", self._name)

15 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

# accessing protected member functions of super

class
self._displayRollAndBranch()

# creating objects of the derived class

obj = Student("R2J", 1706256, "Information Technology")

# calling public member functions of the class

obj.displayDetails()

Output:
Name: R2J
Roll: 1706256
Branch: Information Technology

Private Access Modifier:

The members of a class that are declared private are accessible within the class only,
private access modifier is the most secure access modifier. Data members of a class are
declared private by adding a double underscore ‘__’ symbol before the data member of
that class.

Example: # program to illustrate private access modifier in a class

class Student:

# private members
__name = None
__roll = None
__branch = None

# constructor
def __init__(self, name, roll, branch):
self.__name = name
self.__roll = roll
self.__branch = branch

# private member function

def __displayDetails(self):

# accessing private data members

print("Name: ", self.__name)
print("Roll: ", self.__roll)
print("Branch: ", self.__branch)

# public member function

def accessPrivateFunction(self):

16 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

# accessing private member function

self.__displayDetails()

# creating object
obj = Student("R2J", 1706256, "Information Technology")

# calling public member function of the class

obj.accessPrivateFunction()

Example:
class MyClass:
def __init__(self):
self.public_member = "I am public"
self.__private_member = "I am private"

def get_private(self):
return self.__private_member

# Accessing public member

obj = MyClass()
print(obj.public_member) # Output: I am public

# Accessing private member

print(obj.__private_member) # Raises AttributeError
print(obj.get_private()) # Output: I am private

Inheritance:
Inheritance is a feature of object-oriented programming that allows one class to inherit the
attributes and methods of another class. In Python, there are two main types of inheritance:
1. Single inheritance: A child class inherits from a single parent class. The child class can access
all the attributes and methods of the parent class.
2. Multiple inheritance: A child class inherits from two or more parent classes. The child class
can access all the attributes and methods of all the parent classes.
Inheritance offers several benefits in Python:
1. Code reusability: Inheritance allows you to reuse code from an existing class, instead of
writing the same code again in a new class.
2. Modularity: Inheritance helps to break down complex problems into smaller, more
manageable parts. You can create separate classes for each part of the problem, and then
use inheritance to combine them.
3. Polymorphism: Inheritance allows you to create multiple classes that share the same
attributes and methods, but behave differently. This is known as polymorphism and is a key
feature of object-oriented programming.
4. Flexibility: Inheritance allows you to easily modify or extend the functionality of an existing
class. You can create a child class that inherits from a parent class and then add or modify
methods or attributes as needed.

17 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

Overall, inheritance is a powerful feature of object-oriented programming that allows you to

create flexible, modular, and reusable code. By taking advantage of inheritance, you can
save time and effort, and create more efficient and effective programs.

Example: Define a class called Vehicle with attributes make and model. Create a child class called
Car that inherits from the Vehicle class and has an additional attribute called year. Create an
object of the Car class and print the make, model, and year of the car.

class Vehicle:
def __init__(self, make, model):
self.make = make
self.model = model

class Car(Vehicle):
def __init__(self, make, model, year):
super().__init__(make, model)
self.year = year

car = Car("Toyota", "Corolla", 2022)

print("Make:", car.make)
print("Model:", car.model)
print("Year:", car.year)

In this implementation, we define a Vehicle class with two attributes: make and model. We then
define a Car class that inherits from the Vehicle class and adds an additional attribute: year.
In the __init__() method of the Car class, we call the __init__() method of the Vehicle class using
the super() function, which initializes the make and model attributes. We then set the year
attribute to the value passed in.
We create an instance of the Car class with the make "Toyota", model "Corolla", and year 2022. We
then print the make, model, and year of the car using the instance variables car.make, car.model,
and car.year. The output will be:
Make: Toyota
Model: Corolla
Year: 2022

Polymorphism:
Polymorphism is a way of writing code that can work with different types of objects. It allows you to
use the same method or function name across different classes, so you can write more generic and
reusable code.
There are two main types of polymorphism:
1. Static (compile-time) polymorphism: This involves using overloaded methods or operators
that can take different types of parameters. The correct version of the method or operator
is selected at compile-time based on the type of the parameters.
2. Dynamic (run-time) polymorphism: This involves using inheritance and method overriding to
provide different implementations of a method in different subclasses. The correct version

18 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

of the method is selected at run-time based on the type of the object that is calling the
method.
In Python, there are two main types of polymorphism: method overloading and method overriding.
1. Method overloading: This involves defining multiple methods with the same name in a class,
but with different parameters. When the method is called, the correct version of the
method is chosen based on the number and types of the arguments passed in.
2. Method overriding: This involves creating a method in a subclass with the same name as a
method in the parent class. When the method is called on an instance of the subclass, the
version of the method in the subclass is called instead of the version in the parent class.
The benefits of polymorphism in Python include:
1. Code reuse: Polymorphism allows you to reuse code by creating classes with similar
behavior, but different implementations. This makes it easier to write and maintain code,
since you can use the same code for multiple classes.
2. Flexibility: Polymorphism allows you to write code that can handle different types of objects
without knowing their exact type. This makes your code more flexible and adaptable, and
allows you to write more generic and reusable code.
3. Readability: Polymorphism can make your code more readable by allowing you to use the
same method or function names across different classes, rather than having to create
unique names for each class.
4. Extensibility: Polymorphism allows you to easily extend the behavior of your code by
creating new classes that behave in a similar way to existing classes. This makes it easier to
add new features or functionality to your code, without having to change the existing code.
Example of method overriding:
class Shape:
def area(self):
pass

class Rectangle(Shape):
def __init__(self, width, height):
self.width = width
self.height = height

def area(self):
return self.width * self.height

class Circle(Shape):
def __init__(self, radius):
self.radius = radius
def area(self):
return 3.14 * (self.radius ** 2)

r = Rectangle(10, 5)
c = Circle(7)

19 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

print(r.area()) # 50
print(c.area()) # 153.86 (approx.)

In this example, we have a Shape class that defines a generic area method that does nothing. We
then create two subclasses, Rectangle and Circle, that inherit from Shape and provide their own
implementation of the area method.
The Rectangle class takes a width and height as arguments in its constructor and calculates the
area based on those values. The Circle class takes a radius as an argument in its constructor and
calculates the area using the formula for the area of a circle.
When we create objects of these classes and call their area method, the correct implementation is
called based on the type of the object. This is an example of dynamic (run-time) polymorphism,
which allows us to write more flexible and reusable code.

Example of method overriding:

In Python, method overloading is not directly supported, as it is in some other programming
languages. However, you can achieve a similar effect by using default arguments and *args and
**kwargs arguments. Here's an example of how you might use these techniques to achieve method
overloading in Python:

class MyClass:
def my_method(self, arg1, arg2=None, *args, **kwargs):
if arg2 is not None:
# Do something with arg1 and arg2
else:
# Do something with just arg1

if args:
# Do something with additional arguments
if kwargs:
# Do something with keyword arguments

In this example, the my_method method can be called with one or two arguments. If it is called
with two arguments, it will do one thing, and if it is called with just one argument, it will do
something else. Additionally, it can accept any number of additional arguments using *args and
**kwargs, which allows it to be more flexible.
Here's an example of how you might call the my_method method:

obj = MyClass()
obj.my_method(1)
obj.my_method(1, 2)
obj.my_method(1, 2, 3, 4, foo='bar')

In the first call, only one argument is passed, so the method will do something with just that
argument. In the second call, two arguments are passed, so the method will do something different.

20 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

In the third call, additional arguments and keyword arguments are passed, which the method can
handle using *args and **kwargs.

Example: Define a function called total_area() that takes a list of shapes as an argument
and returns the total area of all the shapes. The shapes can be either Circle or Rectangle
objects. Create objects of both classes and pass them to the total_area() function.

import math

class Circle:
def __init__(self, radius):
self.radius = radius

def area(self):
return math.pi * self.radius ** 2

class Rectangle:
def __init__(self, width, height):
self.width = width
self.height = height

def area(self):
return self.width * self.height

def total_area(shapes):
area = 0
for shape in shapes:
area += shape.area()
return area

# Create some objects of Circle and Rectangle classes

circle1 = Circle(5)
rectangle1 = Rectangle(4, 6)
circle2 = Circle(7)
rectangle2 = Rectangle(3, 8)

# Pass the objects to total_area function and print the result

shapes = [circle1, rectangle1, circle2, rectangle2]
print(total_area(shapes))

n this example, we define two classes Circle and Rectangle, each with their own area() method to
calculate the area of the shape. The total_area() function takes a list of shapes as an argument, and
uses a loop to iterate over each shape in the list and add its area to a running total. The function
then returns the total area of all the shapes.

21 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

We create objects of both Circle and Rectangle classes, and pass them as a list to the total_area()
function to calculate the total area of all the shapes. This approach allows us to work with objects of
different classes in a single function.

Example: Define a class called Student with attributes name, age, and grade. Create a
method in the class that calculates the student's grade point average (GPA). Create an
object of the class and print the student's name, age, and GPA.
class Student:
def __init__(self, name, age, grade):
self.name = name
self.age = age
self.grade = grade

def calculate_gpa(self):
total = sum(self.grade)
gpa = total / len(self.grade)
return gpa

# Create an object of the Student class

s = Student("John Doe", 18, [3.5, 4.0, 3.2, 3.8])

# Print the student's name, age, and GPA

print("Name: ", s.name)
print("Age: ", s.age)
print("GPA: ", s.calculate_gpa())

In this example, we define a Student class with attributes name, age, and grade. The
calculate_gpa() method calculates the student's grade point average by summing the grades and
dividing by the number of grades.
We create an object s of the Student class with the student's name, age, and a list of grades. We
then print the student's name, age, and GPA by calling the calculate_gpa() method.

Exapmle: Define a class called Employee with attributes name, age, and salary. Create an
object of the class and print the employee's name, age, and salary.

class Employee:
def __init__(self, name, age, salary):
self.name = name
self.age = age
self.salary = salary

# Create an object of the Employee class

emp = Employee("John Doe", 25, 50000)

# Print the employee's name, age, and salary

print("Name: ", emp.name)

22 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

print("Age: ", emp.age)

print("Salary: ", emp.salary)

In this example, we define a Employee class with attributes name, age, and salary. The
__init__() method initializes the object with these attributes.
We create an object emp of the Employee class with the employee's name, age, and
salary. We then print the employee's name, age, and salary by accessing these attributes
using the object.

Example: Define a class called Rectangle with attributes length and width. Create an
object of the class and calculate the area of the rectangle.

class Rectangle:
def __init__(self, length, width):
self.length = length
self.width = width

def area(self):
return self.length * self.width

# Create an object of the Rectangle class

rect = Rectangle(5, 10)

# Calculate the area of the rectangle

area = rect.area()

# Print the area of the rectangle

print("Area of the rectangle is: ", area)

In this example, we define a Rectangle class with attributes length and width. The
__init__() method initializes the object with these attributes. We also define an area()
method which calculates and returns the area of the rectangle.
We create an object rect of the Rectangle class with length 5 and width 10. We then call
the area() method of the object rect to calculate the area of the rectangle and store it in a
variable area. Finally, we print the area of the rectangle by printing the value of the variable
area.

Example: Write a python program to create class car with two attributes name &
cost. Create two objects and display information.
class Car:
def __init__(self, name, cost):
self.name = name
self.cost = cost

# Create two objects of the Car class

car1 = Car("Toyota", 15000)
car2 = Car("Honda", 20000)

23 Prof. K.N. Tripathi

 ISBM College of Engineering, Department of AIML
Programming and Problem Solving
Notes:-Unit-5
Course: FE, A Div & B Div

# Print information about the cars

print("Car 1 - Name: ", car1.name, "Cost: ", car1.cost)
print("Car 2 - Name: ", car2.name, "Cost: ", car2.cost)

24 Prof. K.N. Tripathi