1. What is a List, String, and Dictionary in Python?

Answer- Python provides different data structures to store and manipulate data efficiently.
Three of the most commonly used ones are List, String, and Dictionary.
(a) List
A list is a collection of ordered, changeable (mutable) elements and allows duplicate values.
Lists are created using square brackets [] and commas separate elements.
Example of List:
fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4, 5]
mixed = [1, "hello", 3.14]
 Lists allow modification:
fruits[1] = "mango"
# Changes "banana" to "mango"
print(fruits)
# Output: ['apple', 'mango', 'cherry']
(b) String
A string is a sequence of characters enclosed in single quotes (' '), double quotes (" "), or
triple quotes (''' ''' or """ """). Strings are immutable, meaning their values cannot be changed
after creation.
Example of String:
name = "Python"
greeting = 'Hello,
World!'
 Strings cannot be modified directly:
name[0] = "J"
# This will give an error because strings are immutable
(c) Dictionary
A dictionary is an unordered collection of key-value pairs enclosed in curly brackets {}.
Keys must be unique and immutable, while values can be of any type.
Example of Dictionary:
student = {"name": "Alice", "age": 21, "course": "BSc Data Science"}
 Accessing
values:
print(student["name"])
 # Output: Alice
 Modifying a dictionary:
student["age"] = 22 # Changes the age to 22
2. What are Tokens in Python?
Answer- Tokens are the smallest units in a Python program. There are five types of tokens:
(a) Keywords
These are reserved words in Python with special meanings.
Examples: if, else, while, for, def, class, return, import, True, False, etc.
(b) Identifiers
These are names given to variables, functions, classes, etc. Example:
student_name = "John"
def calculate_sum():
return 5 + 3
(c) Literals
Fixed values assigned to variables.
 Integer literal: x = 10
 String literal: name = "Python"
 Boolean literal: flag = True
(d) Operators
Symbols used to perform operations. Examples: +, -, *, /, %, ==, !=, etc.
(e) Punctuators
Special characters used in Python syntax. Examples: (), {}, [], ,, :, ;, ", #, etc.

3. What is the Rule of Identifiers?

Answer- An identifier is the name given to variables, functions, classes, and objects in Python.
The rules for defining an identifier are:
1. Can contain letters, digits, and underscores (_).
Example: student_name, num1, age_25
2. Cannot start with a digit.
Example: 1variable
(invalid) Example:
variable1 (valid)
 3. Cannot be a Python keyword.
Example: def = 5 (invalid because def is a keyword)
4. Case-sensitive.
Example: DataScience and datascience are different.
5. No special characters other than _.
Example: my-variable, num@3
(invalid) Example: my_variable (valid)

4. What is an Escape Sequence?

Answer- Escape sequences are special characters used in strings to perform specific actions
like inserting a new line, tab, or backslash.

Escape Sequence
Meaning

\n New line

\t Tab (space)

\' Single quote

\" Double quote

\\ Backslash

Example of Escape Sequences:

print("Hello\nWorld")
# Output:
Hello
World
print("Python\tProgramming")
# Output: Python Programming
print("She said, \"Hello!\"")
# Output: She said, "Hello!"

5. What is Mutable and Immutable in Python?

Answer- In Python, data types are classified into mutable (changeable) and immutable
(unchangeable).

(a) Mutable Data Types (Can Be Modified)

These can be modified after creation.
 Examples: list, dictionary,
set fruits = ["apple", "banana"]
fruits.append("cherry") # Modifies the list
print(fruits)
# Output: ['apple', 'banana', 'cherry']
(b) Immutable Data Types (Cannot Be Modified)
These cannot be changed once created.
 Examples: string, tuple, int, float
text = "Python"
text[0] = "J" # This will give an error because strings are immutable

6. What is Type Casting?

Answer-Type casting (also known as type conversion) is the process of converting one data
type into another. In Python, there are two types of type casting:
(a) Implicit Type Casting (Automatic Conversion)
 Python automatically converts a smaller data type into a larger data type to
prevent data loss.
 Example:
num = 5 #
Integer
decimal = 4.5 # Float
result = num + decimal
print(result) # Output: 9.5 (integer is converted to float automatically)
(b) Explicit Type Casting (Manual Conversion)
 We use Python's built-in functions to manually convert data types.
 Example:
x = "10" # String
y = int(x) # Converting string to integer
print(y + 5) # Output: 15

 Common Type Casting Functions:

 Function Converts to

int() Integer

float() Float

str() String

list() List

tuple() Tuple

set() Set

7. What is the Rule and Convention for Writing a Python Program?

Answer- To write clean and efficient Python programs, we follow certain rules and
conventions:
(a) Rules for Writing Python Programs
1. Indentation is required
o Python uses indentation (spaces or tabs) to define blocks of code.
def greet():
print("Hello") # Indented properly
Incorrect indentation will cause an error:
def greet():
print("Hello") # Incorrect, no indentation

2. Use meaningful variable names

price = 100 # Good
p = 100 # Bad, not meaningful
3. Follow identifier rules (Letters, digits, and _, but no spaces or special
characters except _).
4. Use correct syntax for loops, conditions, and functions.
if age >= 18:
print("Adult")

(b) Conventions for Writing Python Programs (PEP 8 Guidelines)

 1. Use lowercase letters with underscores for variable and function names
student_name = "Alice" # Good
studentName = "Alice" # Not recommended in Python
2. Use PascalCase for class names
class StudentInfo:
pass
3. Write comments to explain the code.
4. Use spaces around operators
total = 5 + 3 # Good
total=5+3 # Bad

8. What Are Comments in Python?

Answer- Comments are non-executable lines in a Python program used to explain the code.
(a) Single-line Comment
It starts with # and is used for short explanations.
# This is a single-line comment
name = "Alice" # Assigning a name
(b) Multi-line Comment
Uses triple quotes """ """ or ''' '''.
"""
This is a multi-line comment.
It explains the purpose of the
program. """
print("Hello, World!")
(c) Why Use Comments?
 To make code readable
 To explain complex logic
 To temporarily disable parts of the code
 9. Explain Debugging or Types of Errors in Python?
Answer- (a) What is Debugging?
Debugging is the process of finding and fixing errors (bugs) in a program.
(b) Types of Errors in Python
Python errors are mainly divided into three types:
1. Syntax Errors (Wrong Python syntax)
o Example:
print "Hello" # Missing parentheses (Invalid syntax)
o Corrected:
print("Hello") # Correct
2. Runtime Errors (Occurs while executing the program)
o Example:
num = 10 / 0 # Division by zero error
o Corrected:
num = 10 / 2 # Correct
3. Logical Errors (Program runs but gives incorrect output)
o Example:
def add(a, b):
return a - b # Wrong logic (should be +)
print(add(5, 3)) # Output: 2 (Wrong)
o Corrected:
def add(a, b):
return a + b # Correct logic
(c) Debugging Methods
 Using print statements: Print variables at different points to check values.
 Using debugging tools: pdb (Python Debugger), IDE debuggers like PyCharm or
VS Code.
 Code reviews: Getting another programmer to review the code.

 10. Explain Features of Python?
Answer- Python is a powerful, high-level programming language with several unique features:

Feature Description

1. Easy to Learn & Use Python has a simple syntax similar to English.

2. Interpreted Language Python runs line by line, making debugging easier.

3. Dynamically Typed No need to declare variable types explicitly.

4. Open-source & Free Available for free with an active community.

Python code runs on Windows, macOS, and Linux without

5. Platform Independent
modification.

6. Object-Oriented &
Supports both OOP and procedural programming.
Procedural

Comes with built-in modules for tasks like math, file handling, etc.
7. Large Standard Library

8. Extensible & Embeddable

Python can be combined with C, C++, and Java.

9. GUI Programming Support Frameworks like Tkinter and PyQt help in making GUI
applications.

10. Highly Scalable Used in web development, AI, ML, and data science.

Example Showing Python’s Simplicity:

print("Hello, World!") # Simple Python code to print a message.

11. Explain Advantages and Disadvantages of Python

Answer- Python is a widely used programming language with many advantages, but it also has
some limitations.
(a) Advantages of Python
1. Easy to Learn and Use
o Python has a simple syntax that resembles the English language, making
it beginner-friendly.
2. Interpreted Language
o Python code runs line-by-line, making debugging easier.
3. Platform Independent
 o Python can run on Windows, macOS, and Linux without modification.
4. Large Standard Library
o Python provides built-in modules for various tasks, such as file
handling, networking, and data science.
5. Object-Oriented Programming (OOP) Support
o Python supports OOP concepts like classes and objects, making it suitable
for large-scale applications.
6. Extensive Community Support
o Python has a large global community that actively contributes to
its development.
7. Used in Multiple Domains
o Python is used in web development, AI, machine learning, data science,
and automation.
(b) Disadvantages of Python
1. Slower Execution Speed
o Since Python is interpreted, it is slower than compiled languages like C
or Java.
2. High Memory Usage
o Python’s dynamic typing and high-level features require more memory.
3. Not Suitable for Mobile Development
o Python is not commonly used for developing mobile applications.
4. Global Interpreter Lock (GIL)
o Python’s GIL restricts multi-threading, making it less efficient for
parallel computing.
5. Weak in Database Access
o Python’s database access layers are less advanced compared to languages
like Java or C#.

12. Explain Print Function in Python

Answer- The print() function in Python is used to display output on the screen.
(a) Syntax:
print(value1, value2, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
 value1, value2, ...: Values to be printed.
  sep: Defines the separator between values (default is a space).
 end: Defines what comes at the end of the output (default is a newline \n).
 file: Specifies where to output the text (default is the console).
 flush: Used for flushing the output buffer.
(b) Examples:
1. Basic Print Statement
print("Hello, World!") # Output: Hello, World!
2. Printing Multiple Values with Custom Separator
print("Python", "is", "fun", sep="-") # Output: Python-is-fun
3. Using end Parameter to Avoid Newline
print("Hello", end=" ")
print("World!") # Output: Hello World!
4. Printing Variables
name = "Alice" age =
25
print("Name:", name, "Age:", age) # Output: Name: Alice Age: 25

13. What is Data Type?

Answer- A data type defines the type of value stored in a variable. Python has several built- in
data types.
(a) Common Data Types in Python

Data Type
Description Example

int Integer (whole numbers) x = 10

float Floating-point numbers (decimal) y = 10.5

str String (text) name = "Alice"

bool Boolean (True/False) is_active = True

list Ordered, mutable collection fruits = ["apple", "banana"]

tuple Ordered, immutable collection coordinates = (10, 20)

dict Key-value pairs person = {"name": "Alice", "age": 25}

Data Type Description Example

set Unordered, unique elements colours = {"red", "blue"}

(b) Checking the Data Type

We can use the type() function to check the type of a variable.
x = 10
print(type(x)) # Output: <class 'int'>

14. Explain How to Identify Type, Value, and Location of a Variable?

Answer- In Python, we can determine a variable’s type, value, and memory location
using built-in functions.
(a) Identifying the Type of a Variable
 The type() function is used to check the data
type. x = 5.5
print(type(x)) # Output: <class 'float'>
(b) Identifying the Value of a Variable
 The value of a variable is simply accessed by printing
it. y = "Python"
print(y) # Output: Python
(c) Identifying the Memory Location of a Variable
 The id() function returns the memory address where the variable is stored.
a = 10
print(id(a)) # Output: (Memory address, varies each time)

15. Explain How to Declare and Access a Variable?

Answer- (a) Declaring a Variable
A variable is created as soon as a value is assigned to it.
name = "Alice" # String variable
age = 25 # Integer variable
(b) Accessing a Variable
We can access a variable by simply using its name.
print(name) # Output: Alice
print(age) # Output: 25
(c) Assigning Multiple Values to Multiple Variables
Python allows multiple variable assignments in a single
line. x, y, z = 10, 20, 30
print(x, y, z) # Output: 10 20 30
(d) Assigning the Same Value
Python allows assigning the same value to multiple variables in a single line.
Example:
a = b = c = 50
print(a, b, c) # Output: 50 50 50

16. Explain How to Assign Multiple Values to Multiple Variables & Assign Same
Value to Multiple Variables
Answer- (a) Assigning Multiple Values to Multiple Variables
Python allows assigning multiple values to multiple variables in a single line.
Example 1: Assigning Different Values to Different Variables
a, b, c = 10, 20, 30
print(a, b, c) # Output: 10 20 30
Here, a gets 10, b gets 20, and c gets 30.
Example 2: Swapping Two Variables Using Multiple Assignments
x, y = 5, 10
x, y = y, x # Swaps the values
print(x, y) # Output: 10 5

(b) Assigning the Same Value to Multiple Variables

Python allows assigning the same value to multiple variables in a single line.
Example:
x = y = z = 100
print(x, y, z) # Output: 100 100 100
Here, all three variables x, y, and z store the same value 100.
17. Explain All Operators in Python
Answer- Operators in Python are symbols that perform operations on variables and values.
Types of Operators in Python:
1. Arithmetic Operators (Used for mathematical calculations)

Operator Description Example

+ Addition a+b

- Subtraction a-b

* Multiplication a*b

/ Division a/b

// Floor Division a // b

% Modulus (Remainder) a % b

** Exponentiation a ** b

2. Comparison Operators (Used to compare values)

Operator Description Example

== Equal to a == b

!= Not equal to a != b

> Greater than a>b

< Less than a<b

>= Greater than or equal to a >= b

<= Less than or equal to a <= b

3. Logical Operators (Used for logical conditions)

Operator Description Example

and Returns True if both conditions are True a > 10 and b < 20

or Returns True if at least one condition is True a > 10 or b < 20

not Reverses the condition not (a > 10)

4. Bitwise Operators (Used for bitwise operations)

 Operator
Description Example

& AND &b

` OR

^ XOR ^b

~ NOT ~a

<< Left Shift << 2

>> Right Shift >> 2

5. Assignment Operators (Used to assign values to variables)

Operator
Example Equivalent To

= = 10 = 10

+= += 5 =a+5

-= -= 5 =a-5

*= *= 5 =a*5

/= /= 5 =a/5

6. Membership Operators (Checks if a value exists in a sequence)

Operator
Description Example

in Returns True if value is found in sequence "a" in "apple"

not in Returns True if value is NOT found in sequence "b" not in "apple"

7. Identity Operators (Checks if two variables refer to the same memory location)

Operator
Description Example

is Returns True if both variables point to the same object is b

is not Returns True if they point to different objects is not b

18. Explain Input and Eval Function

Answer- (a) Input Function
The input() function allows users to enter values during program execution.
Example:
name = input("Enter your name: ")
 print("Hello, " + name)
Output:
Enter your name: Alice Hello,
Alice
By default, input() returns a string.

(b) Eval Function

The eval() function evaluates and executes an expression entered as a string.
Example:
x = eval(input("Enter an expression: "))
print(x)
Input: 10 + 5 * 2
Output: 20
Warning: eval() should be used carefully as it can execute harmful code.

19. Explain User-Defined Function in Python

Answer- A user-defined function is a function created by the programmer to perform specific
tasks.
(a) Syntax of a Function
def function_name(parameters):
# Function body
return result
(b) Example of a Simple Function
def greet():
print("Hello, Welcome to Python!")

greet() # Output: Hello, Welcome to Python!

(c) Function with Parameters
def add(a, b):
return a + b
print(add(5, 3)) # Output: 8
(d) Function with Default Parameter
def greet(name="User"):
print("Hello,", name)

greet() # Output: Hello, User

greet("Alice") # Output: Hello, Alice

20. Explain the Decision Statement in Python (Selection, Conditional)

Answer- Decision statements allow Python programs to execute different code blocks based
on conditions.
(a) if Statement
Executes a block of code if the condition is True.
age = 18
if age >= 18:
print("You are eligible to vote.")
Output: You are eligible to vote.

(b) if-else Statement

Executes one block if the condition is True, and another block if it is False.
num = 10
if num % 2 == 0:
print("Even number")
else:
print("Odd number")
Output: Even number

(c) if-elif-else Statement

Allows checking multiple conditions.
marks = 85
if marks >= 90:
print("Grade: A")
elif marks >= 75:
print("Grade: B")
else:
print("Grade: C")
Output: Grade: B

21. Explain Looping Statements in Python (Iteration)

Answer- Looping (iteration) in Python is used to execute a block of code multiple times
until a specific condition is met. Python provides two types of loops:
(a) for Loop
 Used when the number of iterations is known.
 Iterates over sequences like lists, tuples, strings, and ranges.
Example:
for i in range(1, 6):
print(i)
Output:
1
2
3
4
5

(b) while Loop

 Used when the number of iterations is not known and depends on a condition.
Example:
count = 1
while count <= 5:
print(count)
count += 1
Output:
1
2
3
4
5

22. What is Nested Iteration or Loop?

Answer- A nested loop means a loop inside another loop. The inner loop runs completely for
each iteration of the outer loop.
Example:
for i in range(1, 4): # Outer loop
for j in range(1, 3): # Inner loop
print(f"i={i}, j={j}")
Output:
i=1, j=1
i=1, j=2
i=2, j=1
i=2, j=2
i=3, j=1
i=3, j=2
Nested loops are commonly used for working with matrices or complex patterns.

23. Explain the Range Function in Python

Answer- The range() function generates a sequence of numbers and is mainly used in loops.
Syntax:
range(start, stop, step)
 start: Beginning number (default is 0)
 stop: Ending number (exclusive)
 step: Difference between consecutive numbers (default is 1)
 Examples:
(a) Using range() in for Loop
for i in range(5):
print(i) # Output: 0 1 2 3 4
(b) Specifying Start and Stop
for i in range(2, 7):
print(i) # Output: 2 3 4 5 6
(c) Using Step
for i in range(1, 10, 2):
print(i) # Output: 1 3 5 7 9
(d) Reverse Order
for i in range(10, 0, -2):
print(i) # Output: 10 8 6 4 2

24. Explain Jump Statements in Python

Answer- Jump statements alter the normal flow of loop execution.
(a) break Statement
Stops the loop when a condition is met.
Example:
for i in range(1, 6):
if i == 3:
break
print(i)
Output:
1
2
The loop stops when i == 3.

(b) continue Statement

Skips the current iteration and moves to the next.
Example:
for i in range(1, 6):
if i == 3:
continue
print(i)
Output:
1
2
4
5
The loop skips 3 but continues executing.

(c) pass Statement

Used as a placeholder when code is not yet implemented.
Example:
for i in range(5):
if i == 3:
pass # Placeholder
print(i)
The program runs without error, even though pass does nothing.

25. Explain Creation, Declaring, Accessing, and Traversing Strings in Python

Answer- A string is a sequence of characters enclosed in quotes.
(a) Creating and Declaring a String
Strings can be created using single, double, or triple quotes.
Example:
str1 = 'Hello'
str2 =
"World"
str3 = '''Python Programming'''
(b) Accessing a String
Strings can be accessed using indexing.
Example:
s = "Python"
print(s[0]) # Output: P
print(s[-1]) # Output: n (negative indexing)

(c) Traversing a String

Using a loop to go through each character.
Example:
s = "Python"
for char in s:
print(char)
Output:
P
y
t
h
o
n

26. Explain Various String Operations (Slicing, Concatenation,

Repetition, Membership, Reverse)
Answer- (a) Slicing
Slicing is used to extract a portion of a string using start:stop:step notation.
Example:
s = "Hello, World!"
print(s[0:5]) # Output: Hello
print(s[7:]) # Output: World!
print(s[::-1]) # Output: !dlroW ,olleH (Reverse string)

(b) Concatenation
Concatenation joins two or more strings using the + operator.
Example:
s1 = "Hello"
s2 = "World"
result = s1 + " " + s2
print(result) # Output: Hello World

(c) Repetition
Repeats a string multiple times using the * operator.
Example:
s = "Hi! "
print(s * 3) # Output: Hi! Hi! Hi!

(d) Membership
Checks whether a substring exists in a string using in or not in.
Example:
s = "Python Programming"
print("Python" in s) # Output:
True print("Java" not in s) #
Output: True

(e) Reverse a String

A string can be reversed using slicing ([::-1]) or a loop.
Example (Using Slicing):
s = "Python"
print(s[::-1]) # Output: nohtyP
Example (Using Loop):
s = "Python"
rev = ""
for char in s:
rev = char + rev
print(rev) # Output: nohtyP

27. Explain Built-in Functions in Strings

Answer- Python provides several built-in string functions:
(a) len() - Get String Length
s = "Hello"
print(len(s)) # Output: 5

(b) upper() and lower() - Change Case

s = "Python"
print(s.upper()) # Output: PYTHON
print(s.lower()) # Output: python

(c) strip() - Remove Whitespaces

s = " Hello "
print(s.strip()) # Output: "Hello"

(d) replace() - Replace Substring

s = "Hello World"
print(s.replace("World", "Python")) # Output: Hello Python
(e) split() and join() - Splitting and Joining Strings
s = "Python Programming"
words = s.split() # Splitting into a list
print(words) # Output: ['Python', 'Programming']

joined = "-".join(words)
print(joined) # Output: Python-Programming
28. Explain Creation, Declaring, Accessing, and Traversing List in Python
Answer- (a) Creating a List
A list is created using square brackets []. It can contain different data types.
Example:
list1 = [10, 20, 30, "Python", True]
print(list1) # Output: [10, 20, 30, 'Python', True]

(b) Accessing Elements

Elements can be accessed using indexing ([]).
Example:
list1 = ["apple", "banana",
"cherry"] print(list1[0]) # Output:
apple print(list1[-1]) # Output:
cherry

(c) Traversing a List (Using

Loop) Iterate through a list using a
loop. Example:
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
print(fruit)
Output:
apple
banana
cherry

29. Explain Creation of List

Answer- Lists can be created in different ways:
(a) Using Square Brackets
list1 = [1, 2, 3, 4]
(b) Using list() Function
list2 = list((10, 20, 30))
print(list2) # Output: [10, 20, 30]
(c) Creating an Empty List
empty_list = []
(d) Using List Comprehension
squares = [x**2 for x in range(5)]
print(squares) # Output: [0, 1, 4, 9, 16]

30. Explain Various Operations on List

Answer- (a) Appending Elements
(append()) Adds an element at the end of the
list.
lst = [1, 2, 3]
lst.append(4)
print(lst) # Output: [1, 2, 3, 4]

(b) Inserting an Element (insert())

Adds an element at a specific index.
lst = [1, 2, 4]
lst.insert(2, 3) # Insert 3 at index 2
print(lst) # Output: [1, 2, 3, 4]

(c) Removing an Element

(remove()) Deletes the first
occurrence of a value. lst = [1, 2, 3, 4]
lst.remove(3)
print(lst) # Output: [1, 2, 4]

(d) Removing Last Element (pop())

lst = [10, 20, 30]
lst.pop()
print(lst) # Output: [10, 20]

(e) Sorting a List (sort())

numbers = [5, 2, 8, 1]
numbers.sort()
print(numbers)

31. Explain Built-in Functions in List

Answer- Python provides several built-in functions for lists that help in performing various
operations like adding, removing, and modifying elements. Some of the most commonly
used built-in functions for lists are:
1. len(list) - Returns the number of elements in the
list. numbers = [10, 20, 30]
print(len(numbers)) # Output: 3
2. max(list) - Returns the largest element in the
list. numbers = [10, 20, 30]
print(max(numbers)) # Output: 30
3. min(list) - Returns the smallest element in the
list. numbers = [10, 20, 30]
print(min(numbers)) # Output: 10
4. sum(list) - Returns the sum of all elements in the list.
numbers = [10, 20, 30]
print(sum(numbers)) # Output: 60
5. list.append(value) - Adds an element to the end of the
list. numbers = [10, 20, 30]
numbers.append(40)
print(numbers) # Output: [10, 20, 30, 40]
6. list.insert(index, value) - Inserts an element at a specific
position. numbers = [10, 20, 30]
numbers.insert(1, 15)
print(numbers) # Output: [10, 15, 20, 30]
 7. list.remove(value) - Removes the first occurrence of a specific
element. numbers = [10, 20, 30, 20]
numbers.remove(20)
print(numbers) # Output: [10, 30, 20]
8. list.pop(index) - Removes and returns the element at the given
index. numbers = [10, 20, 30]
numbers.pop(1)
print(numbers) # Output: [10, 30]
9. list.reverse() - Reverses the order of the
list. numbers = [10, 20, 30]
numbers.reverse()
print(numbers) # Output: [30, 20, 10]
10. list.sort() - Sorts the elements of the list in ascending
order. numbers = [30, 10, 20]
numbers.sort()
print(numbers) # Output: [10, 20, 30]

32. Explain How to Delete an Element in a List

Answer- There are multiple ways to delete elements from a list in Python:
1. Using remove(value) - Removes the first occurrence of a
value. numbers = [10, 20, 30, 20]
numbers.remove(20)
print(numbers) # Output: [10, 30, 20]
2. Using pop(index) - Removes an element at a specific index and returns
it. numbers = [10, 20, 30]
numbers.pop(1)
print(numbers) # Output: [10, 30]
3. Using del keyword - Removes an element at a specific index or deletes the entire
list. numbers = [10, 20, 30]
 del numbers[1]
print(numbers) # Output: [10, 30]
4. Using clear() - Removes all elements from the
list. numbers = [10, 20, 30]
numbers.clear() print(numbers)
# Output: []

33. Explain Creation, Declaring, Accessing, and Traversing Dictionary in

Python Creation and Declaring a Dictionary
Answer- A dictionary in Python is created using curly brackets {} and consists of key-value
pairs.
student =
{ "name":
"John", "age":
20,
"course": "BSc"
}
print(student)
Output:
{'name': 'John', 'age': 20, 'course': 'BSc'}
Accessing Elements in a Dictionary
To access a value, we use the key name inside square brackets [ ] or the get() method.
print(student["name"]) # Output: John
print(student.get("age")) # Output: 20
Traversing a Dictionary
To loop through the keys and values of a dictionary: for
key, value in student.items():
print(key, ":", value)
Output: name :
John age : 20
course : BSc
34. Explain Common Functions in Dictionary
Answer- Python provides many built-in functions for dictionaries:
1. len(dictionary) - Returns the number of key-value pairs.
student = {"name": "John", "age": 20}
print(len(student)) # Output: 2
2. dict.keys() - Returns all the keys.
print(student.keys()) # Output: dict_keys(['name', 'age'])
3. dict.values() - Returns all the values.
print(student.values()) # Output: dict_values(['John', 20])
4. dict.items() - Returns key-value pairs as
tuples. print(student.items())
# Output: dict_items([('name', 'John'), ('age', 20)])
5. dict.get(key, default_value) - Returns the value of a key or a default value if the
key is not found.
print(student.get("name", "Not Found")) # Output: John
print(student.get("course", "Not Found")) # Output: Not Found
6. dict.update({key: value}) - Updates the dictionary with new key-value pairs.
student.update({"course": "BSc"})
print(student) # Output: {'name': 'John', 'age': 20, 'course': 'BSc'}
7. dict.pop(key) - Removes a key-value pair and returns the
value. student.pop("age")
print(student) # Output: {'name': 'John', 'course': 'BSc'}
8. dict.clear() - Removes all elements from the
dictionary. student.clear()
print(student) # Output: {}

35. Explain Operations in Dictionary

Answer- Various operations can be performed on dictionaries:
1. Adding Elements - You can add new key-value
pairs. student["gender"] = "Male"
 print(student) # Output: {'name': 'John', 'age': 20, 'gender': 'Male'}
2. Updating Elements - Modify existing
values. student["age"] = 21
print(student) # Output: {'name': 'John', 'age': 21, 'gender': 'Male'}
3. Deleting Elements - Remove a specific
key. del student["gender"]
print(student) # Output: {'name': 'John', 'age': 21}
4. Merging Dictionaries - Use update() to merge two
dictionaries. extra_info = {"city": "New York", "course": "BSc"}
student.update(extra_info)
print(student) # Output: {'name': 'John', 'age': 21, 'city': 'New York', 'course': 'BSc'

36. Explain Nested Dictionary

Answer- nested dictionary is a dictionary that contains one or more dictionaries as values
within its keys. This allows storing structured data where each key can have a dictionary as
its value.
Example of a Nested Dictionary
students = {
"student1": {"name": "John", "age": 20, "course": "BSc"},
"student2": {"name": "Alice", "age": 22, "course": "BA"},
"student3": {"name": "Bob", "age": 21, "course": "BCom"}
}

print(students)
Output:
{
'student1': {'name': 'John', 'age': 20, 'course': 'BSc'},
'student2': {'name': 'Alice', 'age': 22, 'course': 'BA'},
'student3': {'name': 'Bob', 'age': 21, 'course': 'BCom'}
}
Accessing Values in a Nested Dictionary
To access values, use multiple keys:
print(students["student1"]["name"]) # Output: John
print(students["student3"]["course"]) # Output: BCom
Adding an Entry to a Nested Dictionary
students["student4"] = {"name": "Emma", "age": 23, "course": "BSc"}
print(students)
Modifying an Entry in a Nested Dictionary
students["student2"]["age"] = 23
print(students["student2"]) # Output: {'name': 'Alice', 'age': 23, 'course': 'BA'}
Deleting an Entry in a Nested Dictionary
del students["student3"]
print(students)

37. Explain How to Update, Insert, and Remove an Element in a Dictionary

After Creating It
Answer- Once a dictionary is created, you can modify it by updating, inserting, and removing
elements.
Updating an Element in a Dictionary
Updating a dictionary means modifying the value associated with a specific key.
student = {"name": "John", "age": 20, "course": "BSc"}
student["age"] = 21
print(student)
# Output: {'name': 'John', 'age': 21, 'course': 'BSc'}
You can also update multiple values at once using the update() method:
student.update({"name": "Johnny", "age": 22})
print(student)
# Output: {'name': 'Johnny', 'age': 22, 'course': 'BSc'}

Inserting an Element into a Dictionary

If the key doesn’t exist, assigning a value to it adds a new key-value pair.
student["gender"] = "Male"
print(student)
# Output: {'name': 'John', 'age': 20, 'course': 'BSc', 'gender': 'Male'}

Removing an Element from a Dictionary

There are multiple ways to remove elements from a dictionary:
1. Using del - Deletes a key-value
pair. del student["age"]
print(student)
# Output: {'name': 'John', 'course': 'BSc', 'gender': 'Male'}
2. Using pop(key) - Removes the key-value pair and returns the
value. removed_value = student.pop("gender")
print(student) # Output: {'name': 'John', 'course': 'BSc'}
print(removed_value) # Output: Male
3. Using popitem() - Removes the last inserted key-value
pair. student.popitem()
print(student)
# Output: {'name': 'John'}
4. Using clear() - Removes all elements.
student.clear()
print(student) # Output: {}

38. Explain Set with Various Operations

Answer- Introduction:
A set is a built-in data type in Python representing an unordered collection of unique
elements. Unlike lists or tuples, sets do not allow duplicate values and do not maintain any
specific order of elements. Sets are mutable, meaning we can add or remove items after
creating the set.
The mathematical concept of sets (from set theory) is implemented directly into Python,
making it useful for operations like union, intersection, and difference.
Creating a Set:
Sets are created using curly braces {} or the built-in set() function.
Example:
my_set = {1, 2, 3, 4}
another_set = set([1, 2, 3])

Set Properties:
 Unordered: No guarantee of the order of elements.
 Unique: No duplicate elements are allowed.
 Mutable: Elements can be added or removed.

Various Set Operations:

Operation Syntax Description

Add set.add(element) Adds a single element

Remove set.remove(element) Removes an element (Error if not found)

Discard set.discard(element) Removes element (No error if not found)

Clear set.clear() Removes all elements

Union set1.union(set2) or set1 set2

Intersection set1.intersection(set2) or set1 & set2 Common elements

Difference set1.difference(set2) or set1 - set2 Elements in set1 but not in set2

Subset set1.issubset(set2) Checks if all elements of set1 are in set2

Superset set1.issuperset(set2) Checks if set1 contains all elements of set2

Example Program:
A = {1, 2, 3}
B = {3, 4, 5}

print(A.union(B)) # {1, 2, 3, 4, 5}
print(A.intersection(B)) # {3}
print(A.difference(B)) # {1, 2}

Importance of Sets:
 Useful for removing duplicates from data.
 Useful in mathematical operations like finding intersections and unions.
 Efficient membership testing (e.g., checking if an element exists in a set).

Conclusion:
Sets provide a powerful way of handling unique data collections in Python with fast
operations for mathematical set theory. Their properties make them suitable for tasks where
duplicate entries must be avoided.

39. Explain Tuple with Indexing and Various Operators

Answer- Introduction:
A Tuple is a collection of Python objects separated by commas and enclosed within
parentheses (). Tuples are immutable, meaning once a tuple is created, its elements cannot
be modified. Tuples are used to represent fixed collections of items, such as the coordinates
of a point.

Creating a Tuple:
my_tuple = (10, 20, 30, 40)
 Empty tuple: empty = ()
 Single element tuple: single = (5,) (comma is necessary)

Indexing in Tuple:
 Positive Indexing:
Starts from 0 (left to right).
print(my_tuple[0]) # 10
print(my_tuple[2]) # 30

 Negative Indexing:
Starts from -1 (right to left).
print(my_tuple[-1]) # 40
print(my_tuple[-3]) # 20

Operators Supported by Tuples:

Operator Description Example Output

+ Concatenation (1,2) + (3,4) (1,2,3,4)

* Repetition (1,2) * 2 (1,2,1,2)

in Membership 2 in (1,2,3) True

not in Non-membership 5 not in (1,2,3) True

Example Program:
t1 = (1, 2, 3)
t2 = (4, 5)
print(t1 + t2) # (1, 2, 3, 4, 5)
print(t1 * 2) # (1, 2, 3, 1, 2, 3)
print(2 in t1) # True

Conclusion:
Tuples provide a lightweight, fast, and secure method for representing fixed collections in
Python where data integrity must be preserved.

40. Explain various Functions & Methods of Tuples in Python

Answer- Introduction:
Tuples are an immutable sequence type in Python. Since they cannot be modified after
creation, they have limited methods compared to lists. However, Python provides useful
functions and built-in methods to perform operations on tuples.

Functions applicable to Tuples:

These are general built-in functions:
Function Purpose Example Output

len() Returns the length (number of items) len((1,2,3)) 3

max() Returns the maximum value max((1,5,2)) 5

min() Returns the minimum value min((1,5,2)) 1

sum() Adds all elements (if numeric) sum((1,2,3)) 6

sorted() Returns a sorted list of tuple elements sorted((3,1,2)) [1,2,3]

Note: sorted() returns a list, not a tuple.

Tuple Methods:
Tuples have only two specific methods:

Method Purpose Example Output

count(x) Returns the number of times x appears in the tuple (1,2,1,3).count(1) 2

index(x) Returns the first index of element x (1,2,3).index(2) 1

Examples of Tuple Functions and Methods:

t = (10, 20, 30, 20, 40)

print(len(t)) #5
print(max(t)) # 40
print(min(t)) # 10
print(sum(t)) # 120

print(t.count(20)) #2
print(t.index(30)) #2

Conclusion:
Although tuples are immutable and have limited methods, the available functions and
methods are sufficient for common tasks such as counting occurrences, finding an index,
calculating totals, and retrieving basic statistics like max and min.
37. Explain Difference Between List and
Tuple Introduction:
Both lists and tuples are used to store multiple items in a single variable. However, they
have some key differences mainly in terms of mutability and performance.

Comparison Between List and Tuple:

Basis List Tuple

Lists are mutable (can change Tuples are immutable (cannot

Mutability
after creation). be changed once created).

Syntax Defined using square brackets []. Defined using parentheses ().

Methods Lists have more built-in methods Tuples have limited methods like
Available like append(), remove(), pop(). count(), index().

Lists are slower because they Tuples are faster because they are fixed
Performance
allow changes. in size.

Memory Usage Lists use more memory. Tuples use less memory.

Used when data may need to be Used when data should not be changed
Use Case
modified. (e.g., coordinates, days of the week).

Examples:
List Example:
my_list = [1, 2, 3]
my_list.append(4)
print(my_list) # [1, 2, 3, 4]
Tuple Example:
my_tuple = (1, 2, 3)
# my_tuple.append(4) # Error: Tuples are immutable

Conclusion:
Use lists when you need to store a collection of elements that can change. Use tuples when
you want to protect your data from modification, thereby improving performance and
program safety.
38. What is Dynamic Type Feature in Python? Explain with Suitable
Example Introduction:
One of Python’s most powerful features is that it is a dynamically typed language. In
dynamically typed languages, the type of a variable is determined during runtime, not in
advance.
This allows developers to assign values without declaring types and even change types
later in the code.

Explanation of Dynamic Typing:

 In statically typed languages (like C, Java), you must declare the type of a
variable before using it.
 In Python, you simply assign a value to a variable, and Python will understand
its type automatically.

Example:
x = 10 # x is now an integer
print(type(x)) # Output: <class 'int'>

x = "Python" # x is now a string

print(type(x)) # Output: <class 'str'>

x = 3.14 # x is now a float

print(type(x)) # Output: <class 'float'>
Thus, the type of the variable can change during execution.

Advantages of Dynamic Typing:

 Easier and faster code development.
 Less code required (no type declarations).
 Flexibility in coding.
Disadvantages of Dynamic Typing:
 Increases chances of runtime errors if types are not properly handled.
  May make debugging difficult in large programs.

Importance in Python:
Dynamic typing makes Python simple, fast for prototyping, and excellent for beginners, but it
requires careful programming practices in large applications.

39. Explain Recursion in Python with Suitable Example

Introduction:
Recursion is a programming technique where a function calls itself either directly or indirectly
in order to solve a larger problem by breaking it into smaller sub-problems.
Python allows recursive function calls easily, which is very useful for problems like
factorial, Fibonacci series, tree traversal, etc.

Explanation:
In recursion:
 A function calls itself again and again.
 Every recursion must have a base case that stops further function calls.
 Without a base case, the recursion would go into an infinite loop, causing a
stack overflow.

Example: Finding Factorial Using Recursion

def factorial(n):
if n == 1:
return 1
else:
return n * factorial(n-1)

print(factorial(5))
Output:
120
Working:
 factorial(5) = 5 * factorial(4)
  factorial(4) = 4 * factorial(3)
 factorial(3) = 3 * factorial(2)
 factorial(2) = 2 * factorial(1)
 factorial(1) = 1 (base case)

Advantages of Recursion:
 Reduces code size for complex problems.
 Makes code easier to understand for problems based on tree/graph structures.
Disadvantages:
 Uses more memory due to function call stack.
 May be slower for large problems if not optimized (e.g., with memoization).

Conclusion:
Recursion is a powerful concept in Python that simplifies solving problems involving repeated
sub-tasks, but it must be used carefully to avoid excessive memory usage.
40. Explain Similarity Between String and List
Introduction:
In Python, strings and lists are two important sequence types. Despite representing different
data (characters vs. objects), they share many similarities in how they behave and are
manipulated.

Similarities Between String and List:

Feature String List

Sequence Yes Yes

Indexing Yes Yes

Slicing Yes Yes

Iteration Yes Yes

Length (len) Yes Yes

Concatenation Using + operator Using + operator

Membership Testing
Using in Using in
Examples:
Indexing:
str1 = "Python"
lst1 = [1, 2, 3, 4]

print(str1[0]) # 'P'
print(lst1[0]) # 1
Slicing:
print(str1[1:4]) # 'yth'
print(lst1[1:3]) # [2, 3]
Iteration:
for ch in str1:
print(ch)

for item in lst1:

print(item)
Length:
print(len(str1)) # 6
print(len(lst1)) # 4

Conclusion:
Although strings and lists serve different purposes, they behave similarly as ordered
collections in Python, supporting indexing, slicing, length checking, and membership testing.

41. What is Module in Python? Explain Various Ways to Import Module in a

Python File with Suitable Example
Introduction:
A module in Python is simply a Python file (.py) that contains functions, variables, and
classes which can be reused in other Python programs.
Modules help organize code logically and allow code reusability.
Python provides many built-in modules (like math, os, random) and allows creating custom
modules.

Ways to Import Modules:

Method Syntax Description

Import whole Use module_name.function_name() to

import module_name
module access.

Import specific from module_name import

Import selected functions/classes.
items item1, item2

Import all items from module_name import * Import everything (not recommended).

Import with alias import module_name as alias Use short names for modules.

Examples:
1. Import Whole Module:
python
CopyEdit
import math
print(math.sqrt(16)) # 4.0
2. Import Specific Functions:
python
CopyEdit
from math import sqrt, pow
print(sqrt(25)) # 5.0
print(pow(2, 3)) # 8.0
3. Import All Functions:
python
CopyEdit
from math import *
print(sqrt(36)) # 6.0
4. Import with Alias:
import math as m
print(m.sqrt(49)) # 7.0

Conclusion:
Modules are essential in Python programming to promote code organization, reusability,
and efficiency. Different import methods provide flexibility to the programmer.

42. Explain Various Features of OOP in Python

Object-Oriented Programming (OOP) features:

1. Encapsulation: Bundling data and methods that operate on data within one unit (class).

2. Abstraction: Hiding complexity and showing only essential features.

3. Inheritance: Ability of a class to derive properties and methods from another class.

4. Polymorphism: Ability to take many forms, e.g., method overloading, operator

overloading.

43. What is Class and Object? Explain It with Suitable Example

● Class: A blueprint for creating objects (instances).

● Object: An instance of a class containing attributes (data) and methods (functions).

class Dog:

def __init__(self, name, age):

self.name = name

self.age = age

def bark(self):

return f"{self.name} barks!"

# Creating object of Dog class

dog1 = Dog("Buddy", 3)

print(dog1.name) # Buddy

print(dog1.bark()) # Buddy barks!

44. Explain Default Constructor in Python with Suitable Example

A default constructor is a constructor that doesn’t take any arguments (except self). It is called
when an object is created without passing any arguments.
class Car:

def __init__(self):

self.model = "Toyota"

self.year = 2021

def display(self):

print(f"Model: {self.model}, Year: {self.year}")

# Creating object without arguments

car1 = Car()

car1.display() # Model: Toyota, Year: 2021

45. Explain Parameterized Constructor in Python with Suitable Example

A parameterized constructor allows passing parameters during object creation to initialize the
object with specific values.

class Car:

def __init__(self, model, year):

self.model = model

self.year = year

def display(self):

print(f"Model: {self.model}, Year: {self.year}")

# Creating object with arguments

car1 = Car("Honda", 2022)

car1.display() # Model: Honda, Year: 2022

46. What is Encapsulation? How Python Provides Its Functionality? Explain It with
Suitable Example

Encapsulation is the bundling of data and methods that operate on that data within a single
unit (class). It helps restrict direct access to some of the object’s components and prevents
unintended modification.

In Python, encapsulation is done using private attributes (prefix _ or __) and using getter and
setter methods to access private variables.

class Employee:

def __init__(self, name, salary):

self.name = name

self.__salary = salary # private variable

def get_salary(self):

return self.__salary

def set_salary(self, salary):

if salary > 0:

self.__salary = salary

else:

print("Salary can't be negative!")

# Object creation

emp = Employee("John", 50000)

print(emp.get_salary()) # 50000

emp.set_salary(55000)

print(emp.get_salary()) # 55000

47. What is Inheritance in Python?

Inheritance allows one class (child class) to inherit attributes and methods from another class
(parent class). It promotes code reusability and establishes a relationship between classes.

48. Explain Single Inheritance with Its Purpose, Syntax, Suitable Example, and Output

Single inheritance involves one parent class and one child class. The child class inherits all
attributes and methods from the parent class.

class Animal:
 def speak(self):

print("Animal makes a sound")

class Dog(Animal):

def bark(self):

print("Dog barks")

# Creating object of Dog class

dog1 = Dog()

dog1.speak() # Animal makes a sound

dog1.bark() # Dog barks

49. Explain Multiple Inheritance with Its Purpose, Syntax, Suitable Example, and
Output

Multiple inheritance allows a class to inherit from more than one parent class. It allows
combining functionalities from multiple classes.

class Animal:

def speak(self):

print("Animal makes a sound")

class Pet:

def play(self):

print("Pet plays")

class Dog(Animal, Pet):

def bark(self):

print("Dog barks")

# Creating object of Dog class

dog1 = Dog()
dog1.speak() # Animal makes a sound

dog1.play() # Pet plays

dog1.bark() # Dog barks

50. Explain Multilevel Inheritance with Its Purpose, Syntax, Suitable Example, and
Output

Multilevel inheritance involves a chain of inheritance where a class inherits from a parent
class, and another class inherits from the child class.

class Animal:

def speak(self):

print("Animal makes a sound")

class Dog(Animal):

def bark(self):

print("Dog barks")

class Puppy(Dog):

def whine(self):

print("Puppy whines")

# Creating object of Puppy class

puppy1 = Puppy()

puppy1.speak() # Animal makes a sound

puppy1.bark() # Dog barks

puppy1.whine() # Puppy whines

51. Explain Hierarchical Inheritance with Its Purpose, Syntax, Suitable Example, and
Output

Hierarchical inheritance is when multiple classes inherit from the same parent class.

class Animal:

def speak(self):
 print("Animal makes a sound")

class Dog(Animal):

def bark(self):

print("Dog barks")

class Cat(Animal):

def meow(self):

print("Cat meows")

# Creating objects of Dog and Cat

dog1 = Dog()

cat1 = Cat()

dog1.speak() # Animal makes a sound

dog1.bark() # Dog barks

cat1.speak() # Animal makes a sound

cat1.meow() # Cat meows

52. Explain Hybrid Inheritance with Its Purpose, Syntax, Suitable Example, and Output

Hybrid inheritance is a combination of multiple types of inheritance, such as single, multiple,

and multilevel inheritance.

class Animal:

def speak(self):

print("Animal makes a sound")

class Pet:

def play(self):

print("Pet plays")
class Dog(Animal, Pet):

def bark(self):

print("Dog barks")

class Puppy(Dog):

def whine(self):

print("Puppy whines")

# Creating object of Puppy class

puppy1 = Puppy()

puppy1.speak() # Animal makes a sound

puppy1.play() # Pet plays

puppy1.bark() # Dog barks

puppy1.whine() # Puppy whines

53. Explain Compile time polymorphism or static polymorphism with suitable

examples.

Compile-time polymorphism (also known as method overloading in other languages) refers to

method overloading, but Python doesn’t directly support this. It can be emulated by defining
default parameters.

class Printer:

def print_msg(self, msg="Default message"):

print(msg)

printer = Printer()

printer.print_msg() # Default message

printer.print_msg("Hello, World!") # Hello, World!

54. Explain Run time polymorphism or dynamic polymorphism with suitable example.

Runtime polymorphism refers to method overriding where the method of the child class
overrides the parent class method at runtime.
class Animal:

def speak(self):

print("Animal makes a sound")

class Dog(Animal):

def speak(self):

print("Dog barks")

# Creating object of Dog class

dog1 = Dog()

dog1.speak() # Dog barks (runtime polymorphism)

55. Explain how python support Operator overloading. Explain it with suitable
example.

Python allows us to define the behavior of operators for user-defined classes by using special
methods (magic methods).

class Complex:

def __init__(self, real, imag):

self.real = real

self.imag = imag

def __add__(self, other):

return Complex(self.real + other.real, self.imag + other.imag)

def __str__(self):

return f"{self.real} + {self.imag}i"

# Adding complex numbers

c1 = Complex(3, 4)
c2 = Complex(1, 2)

result = c1 + c2

print(result) # 4 + 6i

56. Operator Overriding

Operator overriding allows us to change the behavior of standard operators when applied to
objects.

class Rectangle:

def __init__(self, width, height):

self.width = width

self.height = height

def __eq__(self, other):

return self.width * self.height == other.width * other.height

# Creating objects

rect1 = Rectangle(5, 10)

rect2 = Rectangle(5, 10)

print(rect1 == rect2) # True (Operator overriding)

42. Explain Parameterised Constructor in Python with Suitable

Example Introduction:
A parameterized constructor in Python is a constructor that accepts parameters during
object creation.
It allows the programmer to pass values at the time of object instantiation.

Definition:
A parameterized constructor enables us to provide different values to different objects.
Syntax:
class ClassName:
def init (self, param1, param2):
# initialization using parameters

Example:
python
CopyEdit
class Student:
def init (self, name, age):
self.name = name
self.age = age

def display(self):
print(f"Name: {self.name}, Age: {self.age}")

# Creating objects with different data

s1 = Student("Alice", 21)
s2 = Student("Bob", 22)

s1.display()
s2.display()
Output:
yaml
CopyEdit
Name: Alice, Age: 21
Name: Bob, Age: 22

Key Points:
  Parameterized constructors make the code dynamic and flexible.
 Different objects can have different initial data.

Conclusion:
Using a parameterized constructor, we can initialize each object differently at the time of
creation, making object-oriented programming more flexible and powerful.

43. What is Encapsulation? How Python Provides Its Functionality? Explain

with Suitable Example
Introduction:
Encapsulation is one of the fundamental concepts of OOP.
It refers to the binding of data and methods that operate on that data into a single unit
(class) and restricting direct access to some components.

Definition:
Encapsulation means hiding the internal details of an object and only exposing necessary
information.
In Python, encapsulation is implemented by making variables private using underscores (_
or ).

Levels of Access Control in Python:

Level Syntax Meaning

Public var Accessible from anywhere

Protected _var Should not be accessed outside class/subclass

Private var Name mangled, not accessible directly

Example:
class Employee:
def init (self, name, salary):
self.name = name
self. salary = salary # private variable
 def show(self):
print(f"Employee: {self.name}, Salary: {self. salary}")

e1 = Employee("John", 50000)
e1.show()

# Accessing private variable directly

# print(e1. salary) # Error: AttributeError

Importance of Encapsulation:
 Protects sensitive data.
 Prevents accidental changes.
 Increases code modularity and maintainability.

Conclusion:
Encapsulation in Python is an effective way to protect object data, ensuring controlled
access and improving program reliability and robustness.

44. What is Inheritance in Python?

Introduction:
Inheritance is another fundamental principle of object-oriented programming (OOP).
It allows a class (child class) to inherit attributes and methods from another class (parent
class).

Definition:
Inheritance allows code reusability and extension of existing classes without modifying
them.
It establishes a relationship between parent and child classes.

Syntax:
class Parent:
# parent class code
class Child(Parent):
# child class code

Types of Inheritance in Python:

1. Single Inheritance
2. Multiple Inheritance
3. Multilevel Inheritance
4. Hierarchical Inheritance
5. Hybrid Inheritance

Example:
class Animal:
def eat(self):
print("Eating...")

class Dog(Animal):
def bark(self):
print("Barking...")

d = Dog()
d.eat() # Inherited from Animal
d.bark() # Defined in Dog

Importance of Inheritance:
 Promotes code reuse.
 Supports polymorphism.
 Enables creation of hierarchical class
structures. Conclusion:
Inheritance in Python supports efficient code design, where new classes can extend existing
functionalities, saving time and effort.
45. Explain Single Inheritance with Its Purpose, Syntax, Suitable Example and Output
Introduction:
Single Inheritance is a type of inheritance in which a child class inherits from only one
parent class.
It is the simplest and most basic form of inheritance.

Purpose:
 To reuse code written in a parent class.
 To add additional features to a child class without changing the parent class.
 To establish an is-a relationship between classes.

Syntax:
class Parent:
# parent class code

class Child(Parent):
# child class code

Example:
class Vehicle:
def show_vehicle(self):
print("This is a vehicle.")

class Car(Vehicle):
def show_car(self):
print("This is a car.")

# Create object of Car

c = Car()
c.show_vehicle() # Output: This is a vehicle.
c.show_car() # Output: This is a car.
Output:
This is a vehicle.
This is a car.

Conclusion:
Single Inheritance helps to create a simple hierarchical structure, promoting reusability
and clean code without rewriting common properties and behaviors.

46. Explain Multiple Inheritance with Its Purpose, Syntax, Suitable Example
and Output
Introduction:
Multiple Inheritance is a type of inheritance where a child class inherits from more than
one parent class.
Python allows multiple inheritance directly, which many languages, like Java, do not.

Purpose:
 To allow a child class to combine features from multiple parent classes.
 Useful when an object needs to share properties and behaviors of different classes.

Syntax:
class Parent1:
# Parent1 code

class Parent2:
# Parent2 code

class Child(Parent1, Parent2):

# Child code

Example:
class Father:
 def father_info(self):
print("Father's side
property.")

class Mother:
def mother_info(self):
print("Mother's side
property.")

class Child(Father, Mother):

def child_info(self):
print("Child's property.")

# Create object
c = Child()
c.father_info()
c.mother_info()
c.child_info()

Output:
Father's side property.
Mother's side
property. Child's
property.

Conclusion:
Multiple Inheritance allows a class to inherit and combine functionalities from multiple
base classes, increasing flexibility in design but requires care to avoid conflicts.
 47. Explain Multilevel Inheritance with Its Purpose, Syntax, Suitable Example
and Output
Introduction:
Multilevel Inheritance refers to a chain where a child class inherits from a parent class,
and another child class inherits from this first child class, forming a chain of inheritance.

Purpose:
 To create hierarchical relationships.
 To gradually build complex classes by extending previous ones.
 Encourages code reuse across multiple levels.

Syntax:
class Grandparent:
# Grandparent class code

class Parent(Grandparent):
# Parent class code

class Child(Parent):
# Child class code

Example:
class Grandfather:
def grandfather_info(self):
print("Grandfather's legacy.")

class Father(Grandfather):
def father_info(self):
print("Father's hard work.")

class Son(Father):
 def son_info(self):
print("Son's future.")

# Create object
s = Son()
s.grandfather_info()
s.father_info()
s.son_info()

Output:
Grandfather's legacy.
Father's hard work.
Son's future.

Conclusion:
Multilevel Inheritance models a real-world hierarchical structure, making it easy to
expand functionality progressively while maintaining order.

48. Explain Hierarchical Inheritance with Its Purpose, Syntax, Suitable Example
and Output
Introduction:
In Hierarchical Inheritance, multiple child classes inherit from the same parent class.
One parent can serve many children.

Purpose:
 To share common behavior among multiple derived classes.
 Reduce code duplication among subclasses.

Syntax:
class Parent:
# Parent code
class Child1(Parent):
# Child1 code

class Child2(Parent):
# Child2 code

Example:
python
CopyEdit
class Animal:
def animal_info(self):
print("This is an animal.")

class Dog(Animal):
def dog_info(self):
print("This is a dog.")

class Cat(Animal):
def cat_info(self):
print("This is a cat.")

# Create objects
d = Dog()
c = Cat()

d.animal_info()
d.dog_info()

c.animal_info()
c.cat_info()

Output:
This is an animal.
This is a dog.
This is an animal.
This is a cat.

Conclusion:
Hierarchical Inheritance is useful for modeling different subtypes of a common parent,
making code organized and easy to extend.

49. Explain Hybrid Inheritance with Its Purpose, Syntax, Suitable Example and Output
Introduction:
Hybrid Inheritance is a combination of two or more types of inheritance (single, multiple,
multilevel, hierarchical) in a single program.

Purpose:
 To model complex relationships between classes.
 To mix different inheritance styles and maximize code reuse.

Syntax:
Hybrid inheritance can be any combination. Commonly it looks like:
class Base:
# Base class

class Derived1(Base):
# Single inheritance

class Derived2(Base):
# Single inheritance
class Derived3(Derived1, Derived2):
# Multiple inheritance

Example:
class School:
def school_info(self):
print("This is a school.")

class Student(School):
def student_info(self):
print("This is a student.")

class Teacher(School):
def teacher_info(self):
print("This is a teacher.")

class Principal(Student,
Teacher): def
principal_info(self):
print("This is a principal.")

# Create object
p = Principal()
p.school_info()
p.student_info()
p.teacher_info()
p.principal_info()

Output:
This is a school.
This is a student.
This is a teacher.
This is a principal.

Conclusion:
Hybrid Inheritance allows flexible and complex class relationships, but requires careful
handling to avoid method resolution conflicts (handled by MRO – Method Resolution
Order in Python).