1. Why to choose python? What can we do with python?

There are several reasons why Python is a popular choice among programmers and
developers. Here are some of the key reasons why people choose Python:

1. Readability and Simplicity: Python is known for its simple and easy-to-read
syntax, which makes it a great language for beginners and experienced
programmers alike. The code written in Python is often more concise and
readable compared to other programming languages, which can lead to
increased productivity and reduced development time.
2. Versatility: Python is a versatile language that can be used for a wide range of
applications. It has extensive libraries and frameworks that make it suitable for
various tasks, such as web development, data analysis, scientific computing,
machine learning, artificial intelligence, automation, and more. Python's
versatility makes it a preferred choice in many different fields.
3. Large and Active Community: Python has a large and active community of
developers, which means there are abundant resources, tutorials, and support
available. This community-driven aspect of Python helps in solving problems,
sharing knowledge, and collaborating on open-source projects. The Python
Package Index (PyPI) provides access to thousands of libraries and modules
that extend the functionality of Python and can save development time.
4. Cross-Platform Compatibility: Python is a cross-platform language, which
means it can run on various operating systems such as Windows, macOS,
Linux, and more. This allows developers to write code on one platform and run
it on another without significant modifications, making it highly portable.
5. Integration and Interoperability: Python can easily integrate with other
languages, allowing you to leverage existing code and libraries written in
languages like C, C++, and Java. This makes it a valuable tool for integrating
different components of a software system.
6. Rapid Prototyping and Development: Python's simplicity and ease of use
enable rapid prototyping and development. The language provides a wide
range of tools and libraries that facilitate quick development cycles, making it
suitable for agile and iterative development processes.
7. Scalability: While Python is known for its simplicity, it can also handle large-
scale projects. It offers frameworks like Django and Flask for web
development, which are highly scalable and widely used in building robust
and high-traffic websites.

Overall, Python's combination of readability, versatility, and strong community

support makes it a powerful programming language that can be used for a wide
range of applications and projects.
2. What is the use of if-else in python? Explain with example. Develop a python program to find
factorial of given number using function

The if-else statement in Python is used for conditional execution of code. It

allows you to check a condition and perform different actions based on
whether the condition is true or false.

Here's an example to illustrate the use of if-else in Python:

# Example: Check if a number is positive or negative

number = int(input("Enter a number: "))

if number > 0:

print("The number is positive.")

elif number < 0:

print("The number is negative.")

else:

print("The number is zero.")

In this example, the user is prompted to enter a number. The program then checks
the value of the number using if-else statements. If the number is greater than 0, it
prints "The number is positive." If the number is less than 0, it prints "The number is
negative." If the number is neither greater nor less than 0, it means the number is 0,
and the program prints "The number is zero."

Now, let's develop a Python program to find the factorial of a given number using a
function:

def factorial(n):

if n == 0:

return 1

else:

return n * factorial(n-1)
number = int(input("Enter a number: "))

if number < 0:

print("Factorial is not defined for negative numbers.")

else:

result = factorial(number)

print("The factorial of", number, "is", result)

In this program, we define a function called factorial that takes an argument n.

Inside the function, we use an if-else statement to check if n is equal to 0. If it is, we
return 1, as the factorial of 0 is defined to be 1. Otherwise, we recursively call the
factorial function with n-1 and multiply it by n. This recursive calculation continues
until n becomes 0.

In the main part of the program, the user is prompted to enter a number. If the
number is negative, a message is displayed stating that the factorial is not defined
for negative numbers. Otherwise, the factorial function is called with the given
number, and the result is printed.

3. Explain python dictionary with example also compare between list and tuple

In Python, a dictionary is a built-in data structure that stores a collection of key-value

pairs. It allows you to access, insert, and remove elements based on their associated
keys. Dictionaries are also known as associative arrays or hash maps in other
programming languages.

Here's an example to demonstrate the use of dictionaries in Python

# Example: Creating and accessing dictionary

student = {

"name": "John",

"age": 20,
 "university": "XYZ University",

"major": "Computer Science"

print(student["name"]) # Accessing value using key

print(student.get("university")) # Accessing value using get() method

student["age"] = 21 # Modifying value

student["gpa"] = 3.8 # Adding new key-value pair

print(student)

In this example, we create a dictionary called student that contains information about
a student, such as their name, age, university, and major. Each key-value pair is
separated by a colon (:), and multiple pairs are enclosed in curly braces ({}). We can
access the values in the dictionary by using the corresponding keys. The print()
function is used to display the values.

We can also modify the values associated with a key or add new key-value pairs to
the dictionary. In the example, we update the age of the student to 21 and add a new
key-value pair for the student's GPA.

Now, let's compare lists and tuples in Python:

Lists and tuples are both used to store collections of items in Python, but they have
some differences in terms of their properties and usage:

1. Mutability: Lists are mutable, meaning that you can change, add, or remove
elements after the list is created. Tuples, on the other hand, are immutable,
which means that once a tuple is created, its elements cannot be modified.
2. Syntax: Lists are defined using square brackets ([]) and elements are
separated by commas. Tuples are defined using parentheses (()) and elements
are also separated by commas.
3. Usage: Lists are commonly used when you need a collection of items that may
change over time or require manipulation. They are suitable for situations
where you want to add, remove, or modify elements. Tuples are often used
when you have a collection of items that should remain unchanged, such as
coordinates, database records, or function arguments.
 4. Performance: Tuples are generally more efficient in terms of memory and
performance compared to lists. Since tuples are immutable, they can be
optimized by the Python interpreter, resulting in faster execution. Lists, being
mutable, require additional memory allocation and management.
5. Support for operations: Lists have more built-in methods and operations
available compared to tuples. For example, lists have methods like append(),
insert(), and remove(), which allow you to modify the list. Tuples have fewer
methods since they are immutable.

In summary, use lists when you need a collection that can be modified, and use
tuples when you want to store a collection of elements that should remain
unchanged. Lists offer flexibility and extensive methods for manipulation, while
tuples provide immutability and better performance.

4. Apply following basic tuple operations and show the resulting output:1.Tuples are immutable
2.Finding the length of the tuple 3.Testing membership operators on tuple 4. Concatenation of
tuple

# Tuples are immutable

my_tuple = (1, 2, 3)

# Trying to modify the tuple will result in an error

# Uncomment the line below to see the error

# my_tuple[0] = 10

# Finding the length of the tuple

length = len(my_tuple)

print("Length of the tuple:", length)

# Testing membership operators on tuple

print(2 in my_tuple) # Check if 2 is present in the tuple

print(4 not in my_tuple) # Check if 4 is not present in the tuple

# Concatenation of tuples

tuple1 = (1, 2, 3)

tuple2 = (4, 5, 6)
concatenated_tuple = tuple1 + tuple2

print("Concatenated tuple:", concatenated_tuple)

Length of the tuple: 3

True

True

Concatenated tuple: (1, 2, 3, 4, 5, 6)

Explanation:

1. Tuples are immutable: In the first part, we create a tuple called my_tuple with
values (1, 2, 3). Trying to modify an element of the tuple (e.g., my_tuple[0] = 10)
will result in a TypeError since tuples are immutable.
2. Finding the length of the tuple: We use the len() function to find the length of
the tuple my_tuple and store it in the variable length. The len() function returns
the number of elements in the tuple.
3. Testing membership operators on tuple: We use the in and not in operators
to check if certain elements are present or not in the tuple my_tuple. In this
case, we check if 2 is present in my_tuple (output: True) and if 4 is not present in
my_tuple (output: True).
4. Concatenation of tuples: We create two tuples, tuple1 and tuple2, with
different values. We use the + operator to concatenate them together and
store the result in the variable concatenated_tuple. The resulting tuple
concatenated_tuple contains all the elements from tuple1 followed by all the
elements from tuple2.

5. Explain the python data types with suitable example. Show string slicing operation with example

Python has several built-in data types that are used to represent different kinds of
values. Here are some commonly used data types in Python along with examples:

1. Numeric Types:
• int: Represents integer values (whole numbers) such as 42 or -10.
Example: age = 25
• float: Represents floating-point numbers (numbers with a decimal
point) such as 3.14 or -0.5. Example: pi = 3.14159
2. String:
• str: Represents a sequence of characters enclosed in single quotes ('')
or double quotes (""). Example: name = "Alice"
3. Boolean:
 • bool: Represents a boolean value, which can be either True or False.
Example: is_valid = True
4. List:
• list: Represents an ordered collection of elements. Lists are mutable,
meaning their elements can be modified. Example: numbers = [1, 2, 3,
4]
5. Tuple:
• tuple: Represents an ordered collection of elements. Tuples are
immutable, meaning their elements cannot be modified once created.
Example: coordinates = (10, 20)
6. Dictionary:
• dict: Represents a collection of key-value pairs. The keys are unique
and used to access the corresponding values. Example: student =
{"name": "Alice", "age": 20, "major": "Computer Science"}

Now, let's see an example of string slicing operation in Python:

# String slicing example

text = "Hello, World!"

# Slicing from index 0 to 4 (exclusive)

substring = text[0:5]

print(substring) # Output: "Hello"

# Slicing from index 7 to the end

substring = text[7:]

print(substring) # Output: "World!"

# Slicing from index -6 to -1

substring = text[-6:-1]

print(substring) # Output: "World"

# Slicing with a step of 2

substring = text[0:12:2]

print(substring) # Output: "HloWrd"

# Reversing the string using slicing

reversed_text = text[::-1]

print(reversed_text) # Output: "!dlroW ,olleH"

In this example, we have a string variable called text that contains the text "Hello,
World!". We perform various string slicing operations on this string:

• In the first slice (text[0:5]), we extract the substring from index 0 to 4

(exclusive), which gives us "Hello".
• In the second slice (text[7:]), we extract the substring from index 7 to the end
of the string, which gives us "World!".
• In the third slice (text[-6:-1]), we extract the substring from index -6 to -1,
which gives us "World".
• In the fourth slice (text[0:12:2]), we extract the substring with a step of 2,
resulting in "HloWrd".
• Finally, we use a negative step value in the slice ( text[::-1]) to reverse the
string, resulting in "!dlroW ,olleH".

6. Explain for loop and while lop with syntax in python with example

In Python, the for loop and while loop are used to repeatedly execute a block of
code. Here's an explanation of each loop along with their syntax and examples:

1. for loop: The for loop is used to iterate over a sequence (such as a list, tuple,
string, or range) or any iterable object in Python.
Syntax:
for item in sequence:

# Code block to be executed

# Example: Printing each item in a list using for loop

numbers = [1, 2, 3, 4, 5]

for number in numbers:

print(number)

1. In this example, the for loop iterates over each item in the numbers list. The
loop variable number takes the value of each item in the list, and the code block
 inside the loop (indented under the for statement) is executed for each
iteration. The result is printing each number in the list.
2. while loop: The while loop is used to repeatedly execute a block of code as
long as a given condition is true.
Syntax:
while condition:

# Code block to be executed

# Example: Counting down from 5 using while loop

count = 5

while count > 0:

print(count)

count -= 1

1. In this example, the while loop repeatedly executes the code block as long as
the condition count > 0 is true. The loop starts with count equal to 5, and for
each iteration, it prints the current value of count and then decrements it by 1.
The loop continues until count becomes 0, at which point the condition is false,
and the loop terminates.

Both for and while loops are fundamental control flow structures in Python, but they
have different use cases. The for loop is typically used when you know the number of
iterations or when iterating over a known sequence or iterable object. The while loop,
on the other hand, is used when the number of iterations is not known beforehand
and depends on a condition that may change during the loop execution.

It's important to ensure that the loop's conditions are correctly defined to avoid
infinite loops that may lead to program freezing or crashing.

7. What is class & Object? How to declare it? explain with example

8. In object-oriented programming (OOP), a class is a blueprint or template for

creating objects. It defines a set of attributes (data) and methods (functions) that
the objects of that class will have. An object, on the other hand, is an instance of a
class. It represents a specific entity or concept based on the class definition.

9. To declare a class in Python, you use the class keyword followed by the class
name. The class can contain attributes (variables) and methods (functions) that
define its behavior. You can then create objects (instances) of the class by calling
the class as if it were a function.
10. Here's an example to illustrate the concept of a class and object in Python:

# Example: Creating a class and objects

class Car:

def __init__(self, brand, model, year):

self.brand = brand

self.model = model

self.year = year

def start_engine(self):

print("Engine started.")

def stop_engine(self):

print("Engine stopped.")

# Creating objects (instances) of the Car class

car1 = Car("Toyota", "Corolla", 2020)

car2 = Car("Honda", "Civic", 2018)

# Accessing attributes of objects

print(car1.brand) # Output: "Toyota"

print(car2.model) # Output: "Civic"

# Calling methods of objects

car1.start_engine() # Output: "Engine started."

car2.stop_engine() # Output: "Engine stopped."

In this example, we define a class called Car using the class keyword. It has attributes
brand, model, and year, as well as methods start_engine() and stop_engine(). The
__init__() method is a special method called the constructor, which is automatically
executed when an object of the class is created. It initializes the attributes of the
object using the provided arguments.
We then create two objects of the Car class, car1 and car2, by calling the class as if it
were a function. We provide the necessary arguments to the constructor to set the
attribute values for each object.

We can access the attributes of the objects using dot notation (e.g., car1.brand,
car2.model) to retrieve their values.

Similarly, we can call the methods of the objects using dot notation (e.g.,
car1.start_engine(), car2.stop_engine()) to perform actions specific to each object.

By using classes and objects, you can create multiple instances that encapsulate data
and behavior, making it easier to manage and organize your code.

11. What is class? How to declare class in python? State the use of parameter ‘self’ in python

In Python, a class is a blueprint or template that defines the attributes and

methods of objects. It serves as a structure for creating objects with similar
properties and behaviors. A class encapsulates related data and functions into
a single entity, providing a way to organize and modularize code.

To declare a class in Python, you use the class keyword followed by the name
of the class. Here's the syntax for declaring a class:

class ClassName:

# Class body

# Attribute and method definitions

You can include attributes (variables) and methods (functions) within the class body
to define the behavior of the objects created from that class.

Example:

# Example: Declaring a simple class in Python

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.")

# Creating an object (instance) of the Person class

person = Person("Alice", 25)

# Accessing attributes and calling methods of the object

print(person.name) # Output: "Alice"

print(person.age) # Output: 25

person.greet() # Output: "Hello, my name is Alice and I am 25 years old."

In this example, we declare a class called Person. It has two attributes, name and age,
and one method, greet(). The __init__() method is a special method called the
constructor, which is automatically called when an object of the class is created. It
takes the self parameter along with other parameters to initialize the object's
attributes.

The self parameter is a reference to the object itself. It is used within the class
methods to access the attributes and methods of the object. By convention, self is
the first parameter of any class method. When calling a method of an object, you
don't need to explicitly pass the self parameter; Python takes care of it automatically.

The self parameter allows each object to maintain its own state and differentiate
itself from other instances of the class. It ensures that the attributes and methods of
an object are accessed and operated on correctly.

In summary, the self parameter in Python is used within class methods to refer to
the object itself. It allows objects to access their own attributes and methods,
enabling proper encapsulation and interaction within the class.

12. What is the use of self parameter? Write a program that will ask to enter roll no,name and
weight of two students and display the details using self parameter

In object-oriented programming, the self parameter is used to refer to the

current instance of a class. It allows the instance to access its own attributes
and methods. When defining methods within a class, the self parameter is
typically the first parameter that is passed.
Here's an example program that asks for the roll number, name, and weight of
two students and displays their details using the self parameter:
class Student:

def __init__(self, roll_no, name, weight):

self.roll_no = roll_no

self.name = name

self.weight = weight

def display_details(self):

print("Roll No:", self.roll_no)

print("Name:", self.name)

print("Weight:", self.weight)

# Create two instances of the Student class

student1 = Student(input("Enter Roll No for student 1: "),

input("Enter Name for student 1: "),

float(input("Enter Weight for student 1: ")))

student2 = Student(input("Enter Roll No for student 2: "),

input("Enter Name for student 2: "),

float(input("Enter Weight for student 2: ")))

# Display details of the two students

print("Details of Student 1:")

student1.display_details()

print("\nDetails of Student 2:")

student2.display_details()

In the above program, we define a Student class with an __init__ method that
initializes the attributes roll_no, name, and weight. The display_details method is used
to display the details of a student.
We create two instances of the Student class, student1 and student2, by taking input
for their roll number, name, and weight. We then call the display_details method on
each instance to display their details using the self parameter.

13. What is constructor in python? Can we overload constructor function in python? Justify your
answer

In Python, a constructor is a special method that is automatically called when

an object of a class is created. It is used to initialize the attributes of the
object. The constructor method in Python is denoted by the name __init__().

The constructor method is defined within a class and it is executed as soon as

an object of that class is created. It is commonly used to assign initial values to
the attributes of the object.

Now, regarding constructor overloading in Python:

Python does not support explicit constructor overloading like some other
programming languages such as Java or C++. In those languages, you can
define multiple constructors with different parameter lists and the appropriate
constructor is called based on the arguments provided.

However, in Python, you can achieve similar functionality using default

argument values in the constructor. By providing default values for some or all
of the constructor parameters, you can create different instances of the class
with varying sets of arguments.

Here's an example to illustrate constructor "overloading" using default

argument values:

class MyClass:

def __init__(self, param1, param2=None):

if param2 is None:

# Constructor with one parameter

self.param1 = param1

else:
 # Constructor with two parameters

self.param1 = param1

self.param2 = param2

def display_params(self):

print("Parameter 1:", self.param1)

if hasattr(self, 'param2'):

print("Parameter 2:", self.param2)

# Creating instances using different constructors

obj1 = MyClass("Value 1")

obj2 = MyClass("Value 1", "Value 2")

# Displaying parameters of objects

obj1.display_params()

obj2.display_params()

In the above example, the MyClass constructor is defined with two parameters, param1
and param2, where param2 has a default value of None. If the constructor is called with
only one argument, it assigns the value to param1 and does not set param2. If the
constructor is called with two arguments, both param1 and param2 are assigned the
respective values.

The display_params method is used to display the values of the parameters. If param2 is
set, it will be displayed; otherwise, it won't be displayed.

So, while Python doesn't have true constructor overloading, you can achieve similar
behavior by utilizing default argument values in the constructor.
14. What is file handling? List opening a file in different mode with example

File handling refers to the process of working with files in a computer system. It
involves operations such as creating, opening, reading, writing, and closing files. File
handling allows you to interact with files on disk and perform various operations on
them.

In Python, you can open a file using different modes, which determine the purpose
of opening the file. Here are some commonly used modes for opening files in
Python:

1. "r" (Read Mode): This mode is used for reading the contents of a file. It is the
default mode when opening a file. If the file doesn't exist, it will raise a
FileNotFoundError. Example:
file = open("example.txt", "r")

content = file.read()

print(content)

file.close()

2. "w" (Write Mode): This mode is used for writing or creating a new file. It will
truncate the file if it already exists. Example:
file = open("example.txt", "w")

file.write("Hello, World!")

file.close()

3. "a" (Append Mode): This mode is used for appending data to an existing file.
The new data will be added at the end of the file. If the file doesn't exist, it will
be created. Example:
file = open("example.txt", "a")

file.write("\nThis is appended content.")

file.close()

4. "x" (Exclusive Creation Mode): This mode is used for creating a new file but
raises a FileExistsError if the file already exists. Example:
try:

file = open("example.txt", "x")

file.write("Hello, World!")
 file.close()

except FileExistsError:

print("File already exists!")

5. "b" (Binary Mode): This mode is used for working with binary files. It can be
combined with other modes such as "rb" for reading a binary file or "wb" for
writing a binary file.
6. "t" (Text Mode): This mode is used for working with text files. It is the default
mode when opening a file, and it can be combined with other modes such as
"rt" for reading a text file or "wt" for writing a text file.

It is important to remember to close the file after you finish working with it, as shown
in the examples above, using the file.close() statement. Alternatively, you can use
the with statement to automatically close the file:

with open("example.txt", "r") as file:

content = file.read()

print(content)

The with statement ensures that the file is properly closed, even if an exception occurs within
the block.

15. List the standard library functions used for accessing file contents with suitable examples

The Python standard library provides several functions for accessing file contents.
Here are some commonly used ones along with suitable examples:

1. open(): This function is used to open a file and returns a file object. It takes the
file path and the mode as parameters.

Example:

file = open("example.txt", "r")

content = file.read()

print(content)

file.close()

2. read(): This method is used to read the entire contents of a file as a string.

Example:

with open("example.txt", "r") as file:

 content = file.read()

print(content)

3. readline(): This method is used to read a single line from the file. It returns the
line as a string.

Example:

with open("example.txt", "r") as file:

line = file.readline()

print(line)

4. readlines(): This method is used to read all the lines from the file and returns
them as a list of strings, where each string represents a line.
with open("example.txt", "r") as file:

lines = file.readlines()

for line in lines:

print(line)

5. write(): This method is used to write data to a file. It takes a string as a

parameter and writes it to the file.

Example:

with open("example.txt", "w") as file:

file.write("Hello, World!")

6. writelines(): This method is used to write multiple lines to a file. It takes a list
of strings as a parameter and writes each string as a separate line in the file.

Example:

lines = ["Line 1\n", "Line 2\n", "Line 3\n"]

with open("example.txt", "w") as file:

file.writelines(lines)

These are just a few examples of standard library functions used for accessing file contents in
Python. The Python standard library offers many more functions and methods for file
handling, such as seek(), tell(), flush(), and more, which provide additional flexibility and
functionality when working with files.
16. Explain the following related operations:

1.opening a file 2.Writing into a file using write() 3.reading from a file using readline() 4. Close file

Certainly! Here's an explanation of the related operations you mentioned:

1. Opening a File: Opening a file involves creating a connection between the file
on disk and your Python program, allowing you to read or write data to/from
the file. The open() function is used to open a file. It takes two parameters: the
file path (either absolute or relative) and the mode in which the file should be
opened (e.g., read, write, append, etc.). When a file is opened, a file object is
returned, which can be used to perform various file operations.
Example:
file = open("example.txt", "r")

Writing into a File using write(): The write() method is used to write data to a file. It
takes a string as a parameter and writes the string to the file. If the file does not exist,
it will be created. If it already exists, the existing contents will be truncated and
overwritten with the new data.
Example:
with open("example.txt", "w") as file:
file.write("Hello, World!")

Reading from a File using readline(): The readline() method is used to read a single
line from a file. It returns the next line of the file as a string. Each time readline() is
called, it moves the file pointer to the next line.
Example:
with open("example.txt", "r") as file:
line = file.readline()
print(line)

Closing a File: After you have finished working with a file, it's important to close it to
free up system resources. You can close a file by calling the close() method on the
file object. When a file is closed, any pending writes are flushed to disk, and further
operations on the file object will raise an error.
Example:
file = open("example.txt", "r")
# Perform operations on the file
file.close()

It is generally recommended to use the with statement when working with files. This
ensures that the file is automatically closed even if an exception occurs, providing a
cleaner and safer approach to file handling.

Please note that these are basic explanations of the operations you mentioned. File
handling in Python offers more functionalities and methods to manipulate files, such
as read(), writelines(), and more, which provide different ways to read and write data
from/to files.

17. Write a program to demonstrate parameterized constructor in base class and derived class

class Person:

def __init__(self, name):

self.name = name

def display(self):

print("Name:", self.name)

class Employee(Person):

def __init__(self, name, emp_id):

super().__init__(name)

self.emp_id = emp_id

def display(self):

super().display()

print("Employee ID:", self.emp_id)

# Creating an instance of the base class

person = Person("John")

person.display()

# Creating an instance of the derived class

employee = Employee("Alice", 123)

employee.display()
In the above program, we have a base class called Person and a derived class called
Employee. Both classes have their own parameterized constructors defined using the
__init__() method.

The Person class has a single parameter name in its constructor. It initializes the name
attribute with the provided value.

The Employee class is derived from the Person class. It has two parameters name and
emp_id in its constructor. It uses the super() function to call the constructor of the
base class Person and passes the name parameter to it. Additionally, it initializes the
emp_id attribute with the provided value.

The display() method is overridden in the Employee class to display both the name
and employee ID. It uses super().display() to call the display() method of the base
class before displaying the employee ID.

In the program, we create an instance of the base class Person and call its display()
method to display the name. Then, we create an instance of the derived class
Employee and call its display() method to display both the name and employee ID.

The output of the program will be:

Name: John

Name: Alice

Employee ID: 123

This demonstrates the use of a parameterized constructor in both the base class and the
derived class

18. What is inheritance? List types of inheritance. Write a program to demonstrate the use of single
inheritance.

Inheritance is a fundamental concept in object-oriented programming that allows a

class to inherit properties and methods from another class. It enables the creation of
a hierarchical relationship between classes, where the derived class (also called the
child or subclass) inherits attributes and behaviors from the base class (also called
the parent or superclass). The derived class can then extend or modify the inherited
attributes and behaviors as needed.

Types of inheritance in Python:

 1. Single Inheritance: In single inheritance, a class inherits from a single base
class. This is the simplest form of inheritance, where a derived class extends
the functionality of a single base class.
2. Multiple Inheritance: In multiple inheritance, a class can inherit from multiple
base classes. This allows the derived class to combine and inherit attributes
and methods from multiple sources. However, multiple inheritance can
introduce complexities, especially if conflicts arise between the inherited
attributes or methods.
3. Multilevel Inheritance: In multilevel inheritance, a class is derived from a base
class, which is itself derived from another base class. It forms a parent-child-
grandchild relationship, where the derived class inherits attributes and
methods from both the immediate parent class and the grandparent class.
4. Hierarchical Inheritance: In hierarchical inheritance, multiple derived classes
inherit from a single base class. This results in a tree-like structure, where a
base class is at the top and several derived classes extend its functionality.
5. Hybrid Inheritance: Hybrid inheritance refers to a combination of different
types of inheritance, such as multiple inheritance and multilevel inheritance. It
involves inheriting from multiple base classes and forming a complex
inheritance hierarchy.

Now, let's demonstrate the use of single inheritance with an example:

class Animal:

def __init__(self, name):

self.name = name

def speak(self):

print("The animal speaks.")

class Dog(Animal):

def __init__(self, name, breed):

super().__init__(name)

self.breed = breed

def speak(self):

print("The dog barks.")

# Creating an instance of the derived class

dog = Dog("Buddy", "Labrador")

print("Name:", dog.name)

print("Breed:", dog.breed)

dog.speak()

In the above program, we have a base class called Animal and a derived class called
Dog, which inherits from the Animal class.

The Animal class has an __init__() method to initialize the name attribute and a speak()
method to display a generic animal sound.

The Dog class is derived from the Animal class. It has an __init__() method that calls
the base class's __init__() method using super() to initialize the name attribute, and it
also has an additional breed attribute. The Dog class overrides the speak() method to
display the specific sound of a dog.

In the program, we create an instance of the Dog class and initialize the name and breed
attributes. We then call the speak() method of the Dog class, which overrides the base
class's speak() method.

The output of the program will be:

Name: Buddy

Breed: Labrador

The dog barks.

This demonstrates the use of single inheritance, where the derived class Dog inherits
attributes and methods from the base class Animal and extends it with its own attributes and
behavior.

19. What is getters and setters in python? Explain with example

In Python, getters and setters are methods that are used to access and modify the
values of class attributes (variables). They provide a way to encapsulate attribute
access and enable controlled access to class data. Getters are used to retrieve the
value of an attribute, while setters are used to set or modify the value of an
attribute.

Here's an example to illustrate the concept of getters and setters in Python:

class Person:

def __init__(self, name):

self._name = name

def get_name(self):

return self._name

def set_name(self, name):

self._name = name

# Creating an instance of the class

person = Person("John")

# Using the getter method to retrieve the name attribute

print(person.get_name()) # Output: John

# Using the setter method to modify the name attribute

person.set_name("Alice")

# Using the getter method again to retrieve the modified name attribute

print(person.get_name()) # Output: Alice

In the above example, we have a Person class with a private attribute _name. The _name
attribute is not directly accessible from outside the class.

The class provides two methods: get_name() and set_name(). The get_name() method is
a getter method that returns the value of the _name attribute. The set_name() method
is a setter method that sets the value of the _name attribute.

When creating an instance of the Person class, we pass the name as a parameter to
the constructor. We can use the get_name() method to retrieve the value of the _name
attribute, and the set_name() method to modify the value of the _name attribute.
In the example, we initially set the name as "John" and retrieve it using the get_name()
method, which returns "John". Then, we use the set_name() method to change the
name to "Alice" and retrieve it again using the get_name() method, which now returns
"Alice".

By using getters and setters, we can control the access to class attributes and
perform additional operations such as validation or logging when retrieving or
modifying the attribute values. It provides a level of abstraction and encapsulation in
the class design.

20. What is polymorphism? Explain with example

Polymorphism is a concept in object-oriented programming that allows objects of

different classes to be treated as objects of a common superclass. It allows methods
with the same name to be implemented in different classes, and the appropriate
method is called based on the type of the object at runtime. In simple terms,
polymorphism enables different objects to respond to the same method in different
ways.

Here's an example to illustrate polymorphism in Python:

class Animal:

def sound(self):

pass

class Dog(Animal):

def sound(self):

print("The dog barks.")

class Cat(Animal):

def sound(self):

print("The cat meows.")

# Creating instances of the derived classes

dog = Dog()

cat = Cat()

# Calling the sound() method on different objects

dog.sound() # Output: The dog barks.

cat.sound() # Output: The cat meows.

In the above example, we have a base class called Animal with a sound() method. The
sound() method is defined in the base class, but it does not have any implementation
(it is empty).

The Dog and Cat classes are derived from the Animal class. They override the sound()
method with their own implementation.

When we create an instance of the Dog class and call the sound() method, it prints
"The dog barks." Similarly, when we create an instance of the Cat class and call the
sound() method, it prints "The cat meows."

Polymorphism allows us to treat objects of different classes that inherit from a

common superclass (Animal in this case) as if they are objects of that superclass. In
the example, even though we call the same method (sound()) on different objects (dog
and cat), the appropriate implementation is invoked based on the type of the object.

Polymorphism helps in creating more flexible and extensible code by allowing

different objects to respond to the same method in different ways. It allows for code
reusability and supports the concept of "writing once and using anywhere."

21. List the standard library functions used for accessing file contents with suitable examples

Certainly! Here are some commonly used standard library functions in Python for
accessing file contents:

1. open(): This function is used to open a file and returns a file object. It takes two
parameters: the file path and the mode in which the file should be opened
(e.g., read, write, append, etc.).
Example:
file = open("example.txt", "r")

read(): This method is used to read the entire contents of a file as a string. It
reads and returns the entire content of the file.
Example:
with open("example.txt", "r") as file:

content = file.read()

print(content)

readline(): This method is used to read a single line from a file. It returns the next line
of the file as a string. Each time readline() is called, it moves the file pointer to the
next line.
Example:
with open("example.txt", "r") as file:

line = file.readline()

print(line)

readlines(): This method is used to read all lines from a file and return them as a list
of strings. Each string represents a line from the file, including the newline character
at the end.
Example:
with open("example.txt", "r") as file:

lines = file.readlines()

for line in lines:

print(line)

write(): This method is used to write data to a file. It takes a string as a parameter
and writes the string to the file. If the file does not exist, it will be created. If it already
exists, the existing contents will be truncated and overwritten with the new data.
Example:
with open("example.txt", "w") as file:

file.write("Hello, World!")

writelines(): This method is used to write a list of strings to a file. It takes a list of
strings as a parameter, where each string represents a line to be written to the file.
Example:
with open("example.txt", "w") as file:

lines = ["Line 1\n", "Line 2\n", "Line 3\n"]

file.writelines(lines)

These are just a few examples of standard library functions used for accessing file contents in
Python. The file handling capabilities provided by these functions allow for various
operations on files, such as reading, writing, appending, and more.