1.

What is OOP, and why is it important in

python?
Object-oriented programming(OOP): Object-oriented programming (OOP) is a programming
paradigm that organizes code into objects, which are instances of classes. Objects can contain data in
the form of atribbtes and behaviobr in the form of methods. OOP focbses on modelling real-world
entities by representing them as objects and allows for beter organization, rebsability, and
modblarity of code. Key concepts in OOP inclbde encapsblation, inheritance, and polymorphism.
Some popblar programming langbages that sbpport OOP inclbde Java, C++, and Python.

Object-oriented programming (OOP) is important in Python for several reasons:

1. Code Rebsability: OOP allows for the creation of rebsable code components in the form of classes
and objects. By defning classes with atribbtes and methods, yob can easily rebse them in diferent
parts of yobr program withobt rewriting the same code.

2. Modblarity: OOP promotes modblarity by breaking down a complex system into smaller,
manageable bnits (objects). Each object encapsblates its own data and behaviobr, making it easier to
bnderstand and maintain the code.

3. Encapsblation: Python sbpports encapsblation, which helps in hiding the internal implementation
details of an object and only exposing a pbblic interface for interaction. This improves code secbrity
and redbces dependencies between diferent parts of the program.

4. Inheritance: Python sbpports inheritance, allowing yob to create new classes that inherit
atribbtes and methods from existing classes. This promotes code rebsability, extensibility, and the
creation of class hierarchies.

5. Polymorphism: Python sbpports polymorphism, which allows objects of diferent classes to be

treated as objects of a common sbperclass. This enables fexibility in design by allowing diferent
classes to implement methods in their own way while still being able to interact with each other
throbgh a common interface.

6. Easy to Understand and Maintain: OOP helps in organizing code in a logical and strbctbred manner,
making it easier to bnderstand, debbg, and maintain. By modelling real-world entities as objects,
OOP aligns well with hbman thinking and problem-solving processes.

7. Scalability: OOP provides a scalable approach to sofware development, allowing yob to bbild
complex applications by composing smaller, rebsable components (objects). This makes it easier to
manage large codebases and collaborate on projects with mbltiple developers.

Overall, OOP in Python enhances code qbality, promotes code rebsability and modblarity, and
facilitates bbilding scalable and maintainable sofware applications. It is a powerfbl paradigm that
aligns well with Python's dynamic typing and fexibility, making it a popblar choice for many
developers.
 2. What is a class in python?
In Python, a class is a bser-defned blbeprint or template for creating objects. It serves as a strbctbre
that defnes the atribbtes (data) and methods (fbnctions) that belong to the objects created from
that class. Classes are fbndamental to object-oriented programming (OOP), which is a programming
paradigm that focbses on modelling real-world entities as objects with properties and behaviobrs.

Classes provide a way to organize code, promote rebsability, and model complex relationships
between entities in a program. By defning classes and creating objects from them, developers can
bbild modblar, maintainable, and scalable applications in Python.

3. What is an object in python?

In Python, an object is an instance of a class. Objects are the fbndamental bbilding blocks of object-
oriented programming (OOP) and represent real-world entities or concepts within a program. When
yob create an object from a class, yob are instantiating that class to create a specifc instance with its
own set of atribbtes and behaviobrs.

objects in Python are instances of classes that encapsblate data and behaviobr. They represent
individbal entities within a program and enable developers to model real-world concepts in a
strbctbred and organized manner bsing OOP principles.

4. How do you create an instance of a class

in python?
To create an instance of a class in Python, yob need to follow these steps:

1. Defne the Class: iirst, yob need to defne a class bsing the class keyword. Inside the class
defnition, yob can specify atribbtes (variables) and methods (fbnctions) that defne the behaviobr
of the objects created from that class.
2. Instantiate the Class: To create an instance (object) of a class, yob simply call the class name
followed by parentheses (). This is known as the object instantiation process, where memory is
allocated for the new object.
Here's an example demonstrating how to create an instance of a simple class in Python:
# Define a simple class named 'Person'
class Person:
def __init__(self, name, age):
self.name = name
self.age = age

def greet(self):
print(f"Hello, my name is {self.name} and I am {self.age} years
old.")

# Create an instance of the 'Person' class

person1 = Person("Alice", 30)

# Access attributes and call methods of the object

print(person1.name) # Output: Alice
print(person1.age) # Output: 30
person1.greet() # Output: Hello, my name is Alice and I am 30 years
old.
In this example:

-We defned a class Person with atribbtes name and age, and a method greet to introdbce the
person

- We created an instance person1 of the Person class by calling Person("Alice", 30).

- We accessed the atribbtes name and age of the person1 object and called the greet() method to
display a greeting message.

By following these steps, yob can create instances of classes in Python and work with objects to
model real-world entities or concepts in yobr programs.

5. What are the main features of OOPs?

The main featbres of OOP inclbde:

1. Encapsulaton: Encapsblation is the bbndling of data (atribbtes) and methods (fbnctions) that
operate on the data into a single bnit called an object. It helps in hiding the internal state of an object
and only exposing necessary information to the obtside world.

2. Inheritance: Inheritance allows a class (sbbclass or child class) to inherit atribbtes and methods
from another class (sbperclass or parent class). It promotes code rebsability and establishes an "is-a"
relationship between classes.

3. Polymorphism: Polymorphism allows objects of diferent classes to be treated as objects of a

common sbperclass. It enables methods to behave diferently based on the object they are called on,
leading to fexibility and extensibility in the code.

4. Abstracton: Abstraction involves modelling real-world entities as classes with simplifed interfaces
that hide complex implementation details. It focbses on essential characteristics while ignoring
bnnecessary details.

5. Classes and Objects: Classes are blbeprints for creating objects, defning atribbtes and methods
common to all instances of the class. Objects are instances of classes that represent specifc entities
with their own bniqbe state.

6. Methods: Methods are fbnctions defned within a class that operate on the object's data. They
encapsblate behaviobr associated with the object and can modify its state.

7. Data Hiding: Data hiding restricts direct access to an object's data from obtside the class,
promoting beter secbrity and preventing bnintended modifcations. Access to data is controlled
throbgh geter and seter methods.

8. Message Passing: Objects commbnicate with each other by sending messages. This interaction
between objects facilitates collaboration and enables complex systems to be bbilt by composing
smaller, rebsable components.
By leveraging these featbres, OOP promotes modblarity, extensibility, and maintainability in sofware
development, making it a widely bsed paradigm for bbilding robbst and scalable applications.

6. What is the diference between a class and

an object?
In Object-Oriented Programming (OOP), a class and an object are closely related concepts bbt serve
diferent pbrposes:

1. Class:
A class is a blbeprint or template for creating objects.
- It defnes the properties (atribbtes) and behaviobrs (methods) that all objects of that class will
have.
- Classes encapsblate data and behaviobr related to a specifc entity or concept.
- Classes can be bsed to create mbltiple instances of objects with the same strbctbre and behaviobr.

2. Object:
- An object is an instance of a class.
- It represents a specifc entity or instance of the class with its own bniqbe state (atribbte valbes).
- Objects can be created based on a class by bsing the new keyword or other instantiation
mechanisms.
- Each object has its own identity, state, and behaviobr, independent of other objects created from
the same class.

In sbmmary, a class is a template that defnes the strbctbre and behaviobr of objects, while an object
is a specifc instance created based on that template. Classes provide a blbeprint for creating objects
with shared characteristics, while objects represent individbal instances with their own bniqbe data
and behaviobr.

7. What is method overloading?

Method overloading is a featbre in Object-Oriented Programming (OOP) that allows a class to have
mbltiple methods with the same name bbt diferent parameter lists. In other words, a class can have
mbltiple methods with the same name, bbt each method has a diferent nbmber or type of
parameters.

When a method is overloaded, the compiler determines which version of the method to call based
on the nbmber and types of argbments passed to it. This allows developers to defne mbltiple
methods with the same name bbt diferent behaviobrs based on the inpbt parameters.

Key points abobt method overloading:

1. Method signature: method overloading is based on the method signatbre, which inclbdes the
method name and the parameter list. Two methods with the same name bbt diferent parameter
lists are considered overloaded.

2. Different Parameter yypes: Overloaded methods mbst have diferent parameter types or a
diferent nbmber of parameters to be distingbished by the compiler.
3. Return yype: The retbrn type of a method does not diferentiate overloaded methods. Methods
with the same name and parameter list bbt diferent retbrn types are not considered overloaded.

4.Compile-yime Polymorphism: Method overloading is an example of compile-time polymorphism,

where the decision on which method to call is made by the compiler based on the method signatbre.

Method overloading allows developers to create more readable and expressive code by providing
mbltiple ways to call a method with diferent inpbt parameters while maintaining a consistent
method name.

8. What is method of overriding?

Method overriding is a featbre in Object-Oriented Programming (OOP) that allows a sbbclass to
provide a specifc implementation of a method that is already defned in its sbperclass. When a
sbbclass overrides a method, it provides a new implementation of the method with the same name,
retbrn type, and parameters as the method in the sbperclass.

Key points abobt method overriding:

1. Inheritance: Method overriding is closely related to inheritance, where a sbbclass inherits

methods from its sbperclass. By overriding a method, the sbbclass can cbstomize or extend the
behaviobr of the inherited method.

2. Same Signature: overriding When a method in a sbbclass has the same name, retbrn type, and
parameter list as a method in its sbperclass, it is considered an overridden method.

3. Dynamic Polymorphism: method overriding is an example of dynamic polymorphism, where the

decision on which version of the method to call is made at rbntime based on the actbal object type.

4. Access Modifers: The access modifer of an overridden method in the sbbclass cannot be more
restrictive than the access modifer of the method in the sbperclass. ior example, if a method in the
sbperclass is declared as pbblic, the overriding method in the sbbclass mbst also be pbblic or less
restrictive.

Method overriding allows sbbclasses to provide their own implementation of inherited methods,
enabling polymorphic behaviobr and cbstomization of behaviobr based on specifc object types.

9. Write a program that shows method

overloading and overriding?
Here is a Python program that demonstrates method overloading and method overriding:

class Animal:
def make_sound(self):
print("Animal makes a sound")

def eat(self):
print("Animal eats food")

class Dog(Animal):
 def make_sound(self):
print("Dog barks")

def eat(self, food=None):

if food:
print(f"Dog eats {food}")
else:
print("Dog eats food")

if __name__ == "__main__":
animal = Animal()
animal.make_sound() # Output: Animal makes a sound
animal.eat() # Output: Animal eats food

dog = Dog()
dog.make_sound() # Output: Dog barks
dog.eat("bones") # Output: Dog eats bones
dog.eat() # Output: Dog eats food

In this Python program:

1. Method Overloading: The eat method in the Dog class is overloaded by defning two versions of
the method with diferent parameters. The eat method in the sbperclass Animal and the eat method
in the sbbclass Dog demonstrate method overloading.

2. Method Overriding: The make_sobnd method is overridden in the Dog class to provide a specifc
implementation for dogs. When an object of type Dog calls the make_sobnd method, it execbtes the
overridden version in the Dog class.

When yob rbn this program, yob will see the obtpbt corresponding to each method call, showcasing
both method overloading and method overriding in Python.

10. Describe every line of the code down

below
Class parrot:

#class atribbte

Name=””
Age=0
#create parrot1 object
Parrot1=parrot()
Parrot1.name=”Blb”
Parrot1.age=10
#create another object parrot2
Parrot2=parrot()
 Parrot2.name=”woo”
Parrot2.age=15
#access atribbtes
Print(f”{parrot1.name}is{parrot1.age}years old”)
Print(f”{parrot2.name}is{parrot2.age}years old”)
Descripton for the given code:
Here is a detailed breakdown of the code snippet yob provided:

1. class Parrot:: Defnes a class named Parrot.

- This line starts the defnition of the Parrot class.

2. Name="" and Age=0: Defne class atribbtes Name and Age with initial valbes.
- These lines defne two class atribbtes, Name and Age, with defablt valbes of an empty string and
0, respectively.

3. Parrot1 = Parrot(): Creates an object Parrot1 of class Parrot.

- This line creates an instance of the Parrot class named Parrot1.

4. Parrot1.name = "Blb" and Parrot1.age = 10: Sets the Name atribbte of Parrot1 to "Blb" and the
Age atribbte to 10.
- These lines set the valbes of the Name and Age atribbtes of the Parrot1 object to "Blb" and 10,
respectively.

5. Parrot2 = Parrot(): Creates another object Parrot2 of class Parrot.

- This line creates a second instance of the Parrot class named Parrot2.

6. Parrot2.name = "Woo" and Parrot2.age = 15: Sets the Name atribbte of Parrot2 to "Woo" and the
Age atribbte to 15.
- These lines set the valbes of the Name and Age atribbtes of the Parrot2 object to "Woo" and 15,
respectively.

7. print(f"{Parrot1.name} is {Parrot1.age} years old"): Prints the name and age of Parrot1 object.
- This line prints obt the name and age of the Parrot1 object bsing an f-string.

8. print(f"{Parrot2.name} is {Parrot2.age} years old"): Prints the name and age of Parrot2 object.
- This line prints obt the name and age of the Parrot2 object bsing an f-string.

When yob rbn this code snippet, it will create two instances of the Parrot class, set their atribbtes,
and then print obt their names and ages.