OOPS & Python Programming (4351108) - Summer 2025 Solution

Question 1(a) [3 marks]

#

What is the purpose of a for loop in Python? Write an example.

Answer: A for loop is used to iterate over a sequence (like list, tuple, string) or other iterable objects and execute a block of code for each item in the sequence.

Code Example:

# Print each fruit in a list
fruits = ["apple", "banana", "cherry"]
for fruit in fruits:
    print(fruit)

• Iteration: Automatically repeats code for each item
• Simplicity: Cleaner than using while loops with counters

Mnemonic: “For Each Item Do”

Question 1(b) [4 marks]

#

List out rules for defining variables in python and list out data types in python.

Answer:

Rules for defining variables:

Python Data Types:

• Variable rules: Make them descriptive and meaningful
• Data types: Python automatically determines the type

Mnemonic: “SILB-DTS” (String, Integer, List, Boolean, Dictionary, Tuple, Set)

Question 1(c) [7 marks]

#

Create a program to print prime numbers between 1 to N.

Answer:

def print_primes(n):
    print("Prime numbers between 1 and", n, "are:")
    
    for num in range(2, n + 1):
        is_prime = True
        
        # Check if num is divisible by any number from 2 to sqrt(num)
        for i in range(2, int(num**0.5) + 1):
            if num % i == 0:
                is_prime = False
                break
                
        if is_prime:
            print(num, end=" ")

# Get input from user
N = int(input("Enter a number N: "))
print_primes(N)

Algorithm Diagram:

flowchart TD
    A[Start] --> B[Input N]
    B --> C[Initialize num = 2]
    C --> D{Is num <= N?}
    D -->|Yes| E[Assume num is prime]
    D -->|No| L[End]
    E --> F[Set i = 2]
    F --> G{Is i <= sqrt(num)?}
    G -->|Yes| H{Is num divisible by i?}
    G -->|No| J[Print num]
    H -->|Yes| I[num is not prime]
    H -->|No| K[Increment i]
    K --> G
    I --> M[Increment num]
    J --> M
    M --> D

• Time complexity: O(N√N) - Optimized with square root approach
• Space complexity: O(1) - Only uses constant space

Mnemonic: “Divide To Decide Prime”

Question 1(c) OR [7 marks]

#

Explain working of break, continue and pass statement in Python with examples.

Answer:

1. break statement:

# Exit loop when finding number 5
for num in range(1, 10):
    if num == 5:
        print("Found 5, breaking loop")
        break
    print(num)
# Output: 1 2 3 4 Found 5, breaking loop

2. continue statement:

# Skip even numbers
for num in range(1, 6):
    if num % 2 == 0:
        continue
    print(num)
# Output: 1 3 5

3. pass statement:

# Empty function implementation
def my_function():
    pass

# Empty conditional block
x = 10
if x > 5:
    pass  # will implement later

Flow Control Diagram:

flowchart TD
    A[Loop Start] --> B{Condition}
    B -->|True| C[Process]
    C --> D{break?}
    D -->|Yes| E[Exit Loop]
    D -->|No| F{continue?}
    F -->|Yes| G[Skip to Next Iteration]
    F -->|No| H{pass?}
    H -->|Yes| I[Do Nothing]
    H -->|No| J[Execute Code]
    I --> B
    J --> B
    G --> B

• break: Exits completely from the loop
• continue: Jumps to the next iteration
• pass: Does nothing, placeholder for future code

Mnemonic: “BCP - Break Completely, Continue Partially, Pass silently”

Question 2(a) [3 marks]

#

Create a program that asks the user for a year and prints out whether it is a leap year or not.

Answer:

def is_leap_year(year):
    # A leap year is divisible by 4
    # But if it's divisible by 100, it must also be divisible by 400
    if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
        return True
    else:
        return False

# Get input from user
year = int(input("Enter a year: "))

# Check if it's a leap year
if is_leap_year(year):
    print(f"{year} is a leap year")
else:
    print(f"{year} is not a leap year")

Decision Tree:

flowchart TD
    A[Start] --> B[Input year]
    B --> C{year % 4 == 0?}
    C -->|Yes| D{year % 100 == 0?}
    C -->|No| E[Not a Leap Year]
    D -->|Yes| F{year % 400 == 0?}
    D -->|No| G[Leap Year]
    F -->|Yes| G
    F -->|No| E

• Rule 1: Divisible by 4, not by 100
• Rule 2: Or divisible by 400

Mnemonic: “4 Yes, 100 No, 400 Yes”

Question 2(b) [4 marks]

#

What are the key differences between a list and a tuple in Python?

Answer:

Comparison Diagram:

graph LR
    subgraph List
    A[fruits = ['apple', 'banana']] --> B[fruits.append('orange')]
    end
    subgraph Tuple
    C[coordinates = (10, 20)] --> D[Cannot modify elements]
    end

• Lists: When you need to modify the collection
• Tuples: When you need immutable data (faster, safer)

Mnemonic: “LIST - Lets Items Stay Transformable, TUPLE - Totally Unchangeable Permanent List Elements”

Question 2(c) [7 marks]

#

Create a program to find the sum of all the positive numbers entered by the user. As soon as the user enters a negative number, stop taking in any further input from the user and display the sum.

Answer:

def sum_positives():
    total_sum = 0
    
    while True:
        num = float(input("Enter a number (negative to stop): "))
        
        # Check if number is negative
        if num < 0:
            break
            
        # Add positive number to total
        total_sum += num
    
    print(f"Sum of all positive numbers: {total_sum}")

# Run the function
sum_positives()

Process Flow:

flowchart TD
    A[Start] --> B[Initialize total_sum = 0]
    B --> C[Input number]
    C --> D{Is number < 0?}
    D -->|Yes| E[Display sum]
    D -->|No| F[Add to total_sum]
    F --> C
    E --> G[End]

• Loop control: Terminates on negative input
• Accumulator: Adds each positive number to running total

Mnemonic: “Sum Till Negative”

Question 2(a) OR [3 marks]

#

Create a program to find a maximum number among the given three numbers.

Answer:

# Get three numbers from user
num1 = float(input("Enter first number: "))
num2 = float(input("Enter second number: "))
num3 = float(input("Enter third number: "))

# Find maximum using if-else
if num1 >= num2 and num1 >= num3:
    maximum = num1
elif num2 >= num1 and num2 >= num3:
    maximum = num2
else:
    maximum = num3

print(f"Maximum number is: {maximum}")

# Alternative using built-in max() function
# maximum = max(num1, num2, num3)
# print(f"Maximum number is: {maximum}")

Comparison Logic:

flowchart TD
    A[Start] --> B[Input num1, num2, num3]
    B --> C{num1 >= num2 AND num1 >= num3?}
    C -->|Yes| D[maximum = num1]
    C -->|No| E{num2 >= num1 AND num2 >= num3?}
    E -->|Yes| F[maximum = num2]
    E -->|No| G[maximum = num3]
    D --> H[Display maximum]
    F --> H
    G --> H
    H --> I[End]

• Comparison: Uses logical operators to find maximum
• Alternative: Built-in max() function for simplicity

Mnemonic: “Compare Each, Take Largest”

Question 2(b) OR [4 marks]

#

Given the str=“abcdefghijklmnopqrstuvwxyz”. Write a python program to extract every second character from above string.

Answer:

# Given string
str = "abcdefghijklmnopqrstuvwxyz"

# Extract every second character using slicing
# The syntax is [start:end:step]
# start=0 (beginning), end=len(str) (end of string), step=2 (every second character)
result = str[0::2]

print("Original string:", str)
print("Every second character:", result)
# Output: Every second character: acegikmoqsuwy

String Slicing Diagram:

+---+---+---+---+---+---+---+---+---+---+---+
| a | b | c | d | e | f | g | h | i | j | k |...
+---+---+---+---+---+---+---+---+---+---+---+
  ^       ^       ^       ^       ^
  |       |       |       |       |
  0       2       4       6       8   (indices)

• String slicing: [start🔚step] syntax
• Step value: 2 selects every second character

Mnemonic: “Slice Step Selector”

Question 2(c) OR [7 marks]

#

Write a Python program to create a dictionary that stores student names and their marks. Display the names of students who have scored more than 75 marks.

Answer:

def high_scorers():
    # Create empty dictionary
    students = {}
    
    # Get number of students
    n = int(input("Enter number of students: "))
    
    # Input student data
    for i in range(n):
        name = input(f"Enter name of student {i+1}: ")
        marks = float(input(f"Enter marks of student {i+1}: "))
        students[name] = marks
    
    # Display dictionary
    print("\nStudent Records:", students)
    
    # Display high scorers
    print("\nStudents who scored more than 75 marks:")
    for name, marks in students.items():
        if marks > 75:
            print(f"{name}: {marks}")

# Run the function
high_scorers()

Process Diagram:

flowchart TD
    A[Start] --> B[Create empty dictionary]
    B --> C[Input n students]
    C --> D[Loop through n times]
    D --> E[Input name and marks]
    E --> F[Add to dictionary]
    F --> D
    D --> G[Display all records]
    G --> H[Loop through dictionary]
    H --> I{marks > 75?}
    I -->|Yes| J[Display name]
    I -->|No| K[Skip]
    J --> H
    K --> H
    H --> L[End]

• Dictionary: Key-value pairs of student names and marks
• Conditional filtering: Selects high scorers (>75)

Mnemonic: “Store All, Filter Some”

Question 3(a) [3 marks]

#

Write a program to find the length of a string excluding spaces.

Answer:

def length_without_spaces():
    # Get input string
    input_string = input("Enter a string: ")
    
    # Remove spaces and calculate length
    # Method 1: Using replace
    no_spaces = input_string.replace(" ", "")
    length = len(no_spaces)
    
    # Method 2: Using a counter
    # count = 0
    # for char in input_string:
    #     if char != " ":
    #         count += 1
    
    print(f"Original string: '{input_string}'")
    print(f"Length excluding spaces: {length}")

# Run the function
length_without_spaces()

String Processing:

"Hello World" → "HelloWorld" → Length: 10

• Space removal: Using replace() or filtering
• String length: Calculated after space removal

Mnemonic: “Count Characters, Skip Spaces”

Question 3(b) [4 marks]

#

List the dictionary methods in python and explain each with suitable examples.

Answer:

Code Example:

student = {'name': 'John', 'age': 20, 'grade': 'A'}

# get method
print(student.get('name'))  # Output: John
print(student.get('city', 'Not found'))  # Output: Not found

# update method
student.update({'city': 'New York', 'grade': 'A+'})
print(student)  # {'name': 'John', 'age': 20, 'grade': 'A+', 'city': 'New York'}

# pop method
removed = student.pop('age')
print(removed)  # 20
print(student)  # {'name': 'John', 'grade': 'A+', 'city': 'New York'}

• Access methods: get(), keys(), values(), items()
• Modification methods: update(), pop(), clear()

Mnemonic: “GCUP-KPIV” (Get-Copy-Update-Pop, Keys-Pop-Items-Values)

Question 3(c) [7 marks]

#

Explain Python’s List data type in detail.

Answer:

Python List: An ordered, mutable collection that can store items of different data types.

Common List Methods:

List Operations Diagram:

graph LR
    A["fruits = ['apple', 'banana']"] --> B["fruits.append('orange')"]
    B --> C["fruits.insert(1, 'mango')"]
    C --> D["fruits.pop(0)"]
    D --> E["fruits.sort()"]
    E --> F["['mango', 'orange']"]

• Versatility: Stores different data types in one collection
• Dynamic sizing: Grows or shrinks as needed

Mnemonic: “CAMP-IS” (Create, Access, Modify, Process, Index, Slice)

Question 3(a) OR [3 marks]

#

Write a program to input a string from the user and print it in the reverse order without creating a new string.

Answer:

def reverse_string():
    # Get input string
    input_string = input("Enter a string: ")
    
    # Print original string
    print(f"Original string: {input_string}")
    
    # Print reversed string using slice notation
    # The syntax is [start:end:step]
    # start=None (default), end=None (default), step=-1 (reverse)
    print(f"Reversed string: {input_string[::-1]}")

# Run the function
reverse_string()

String Reversing Visualization:

"Hello" → "olleH"

Indices:  0   1   2   3   4
String:   H   e   l   l   o
Reversed: o   l   l   e   H
Indices: -1  -2  -3  -4  -5

• Slicing with negative step: Reverses without new string
• Efficient: No extra memory used for new string

Mnemonic: “Slice Backwards”

Question 3(b) OR [4 marks]

#

List the dictionary operations in python and explain each with suitable examples.

Answer:

Code Example:

# Creation
student = {'name': 'John', 'age': 20}

# Access
print(student['name'])  # Output: John

# Assignment
student['grade'] = 'A'  # Add new key-value pair
student['age'] = 21     # Update existing value

# Membership test
if 'grade' in student:
    print("Grade exists")  # Will be printed

# Deletion
del student['age']
print(student)  # {'name': 'John', 'grade': 'A'}

# Dictionary comprehension
squares = {x: x**2 for x in range(1, 5)}
print(squares)  # {1: 1, 2: 4, 3: 9, 4: 16}

• Key-based access: Fast lookup by keys
• Dynamic structure: Add/remove items as needed

Mnemonic: “CADMIL” (Create, Access, Delete, Modify, Iterate, Length)

Question 3(c) OR [7 marks]

#

Explain Python’s set data type in detail.

Answer:

Python Set: An unordered collection of unique, immutable items.

Common Set Operations:

Set Operations Diagram:

graph LR
    A["A = {1, 2, 3}"] --> B["B = {3, 4, 5}"]
    A --> C["A | B = {1, 2, 3, 4, 5}"]
    A --> D["A & B = {3}"]
    A --> E["A - B = {1, 2}"]
    A --> F["A ^ B = {1, 2, 4, 5}"]

• Fast membership: O(1) average time complexity
• Mathematical operations: Set theory operations built-in

Mnemonic: “SUMO” (Sets are Unique, Mutable, and Ordered-less)

Question 4(a) [3 marks]

#

Explain statistics module with any three methods.

Answer:

The statistics module provides functions for calculating mathematical statistics of numeric data.

Code Example:

import statistics

data = [2, 5, 7, 9, 12, 13, 14, 5]

# Mean (average)
print("Mean:", statistics.mean(data))  # Output: 8.375

# Median (middle value)
print("Median:", statistics.median(data))  # Output: 8.0

# Mode (most frequent)
print("Mode:", statistics.mode(data))  # Output: 5

• Data analysis: Functions for statistical calculations
• Built-in module: No external installation needed

Mnemonic: “MMM Stats” (Mean, Median, Mode Statistics)

Question 4(b) [4 marks]

#

Explain function of user define function and user defined module in Python.

Answer:

User-defined Function Example:

# Function definition
def calculate_area(length, width):
    """Calculate area of rectangle"""
    area = length * width
    return area

# Function call
result = calculate_area(5, 3)
print("Area:", result)  # Output: 15

User-defined Module Example:

# File: geometry.py
def calculate_area(length, width):
    return length * width

def calculate_perimeter(length, width):
    return 2 * (length + width)

# In another file
import geometry

area = geometry.calculate_area(5, 3)
print("Area:", area)  # Output: 15

Module Organization:

graph TD
    A[Main Program] --> B[import geometry]
    B --> C[geometry.py]
    C --> D[calculate_area]
    C --> E[calculate_perimeter]

• Function benefits: Code reuse, modular design
• Module benefits: Organized code, namespace separation

Mnemonic: “FIR-MID” (Functions for Internal Reuse, Modules for Inter-file Distribution)

Question 4(c) [7 marks]

#

Write a Python code using user defined function to find the factorial of a given number using recursion.

Answer:

def factorial(n):
    """
    Calculate factorial of n using recursion
    n! = n * (n-1)!
    """
    # Base case: factorial of 0 or 1 is 1
    if n == 0 or n == 1:
        return 1
    
    # Recursive case: n! = n * (n-1)!
    else:
        return n * factorial(n-1)

# Get input from user
number = int(input("Enter a positive integer: "))

# Check if input is valid
if number < 0:
    print("Factorial is not defined for negative numbers.")
else:
    # Calculate and display result
    result = factorial(number)
    print(f"Factorial of {number} is {result}")

Recursive Function Visualization:

graph TD
    A["factorial(4)"] --> B["4 * factorial(3)"]
    B --> C["4 * (3 * factorial(2))"]
    C --> D["4 * (3 * (2 * factorial(1)))"]
    D --> E["4 * (3 * (2 * 1))"]
    E --> F["4 * (3 * 2)"]
    F --> G["4 * 6"]
    G --> H["24"]

• Base case: Stops recursion when n=0 or n=1
• Recursive case: Breaks problem into smaller subproblems

Mnemonic: “Factorial = Number times (Number minus one)!”

Question 4(a) OR [3 marks]

#

Explain math module with any three methods.

Answer:

The math module provides access to mathematical functions defined by the C standard.

Code Example:

import math

# Square root
print("Square root of 25:", math.sqrt(25))  # Output: 5.0

# Power
print("2 raised to power 3:", math.pow(2, 3))  # Output: 8.0

# Constants
print("Value of pi:", math.pi)  # Output: 3.141592653589793

• Mathematical operations: Advanced math functions
• Constants: Mathematical constants like pi and e

Mnemonic: “SPT Math” (Square root, Power, Trigonometry in Math module)

Question 4(b) OR [4 marks]

#

Explain the concepts of global and local variables in Python.

Answer:

Example:

# Global variable
total = 0

def add_numbers(a, b):
    # Local variables
    result = a + b
    
    # Accessing global variable
    global total
    total += result
    
    return result

# Function call
sum_result = add_numbers(5, 3)
print("Sum:", sum_result)  # Output: 8
print("Total:", total)  # Output: 8

Variable Scope Diagram:

graph TD
    A[Global Scope] --> B[total]
    A --> C[add_numbers function]
    C --> D[Local Scope]
    D --> E[a, b, result]
    D --> F[global total]
    F --> B

• Global: Accessible everywhere but needs global keyword to modify
• Local: Limited to function scope, freed after function execution

Mnemonic: “GLOBAL Goes Everywhere, LOCAL Lives in Functions”

Question 4(c) OR [7 marks]

#

Create code with user defined function to check if given string is palindrome or not.

Answer:

def is_palindrome(text):
    """
    Check if a string is a palindrome.
    A palindrome reads the same forwards and backwards.
    """
    # Remove spaces and convert to lowercase
    cleaned_text = text.replace(" ", "").lower()
    
    # Check if the string equals its reverse
    return cleaned_text == cleaned_text[::-1]

def check_palindrome():
    # Get input from user
    input_string = input("Enter a string: ")
    
    # Check if it's a palindrome
    if is_palindrome(input_string):
        print(f"'{input_string}' is a palindrome!")
    else:
        print(f"'{input_string}' is not a palindrome.")
    
    # Examples for reference
    print("\nExamples of palindromes:")
    print("'radar' →", is_palindrome("radar"))
    print("'level' →", is_palindrome("level"))
    print("'A man a plan a canal Panama' →", is_palindrome("A man a plan a canal Panama"))

# Run the function
check_palindrome()

Palindrome Testing Process:

flowchart TD
    A[Start] --> B[Input string]
    B --> C[Clean string: remove spaces, convert to lowercase]
    C --> D[Check if string equals its reverse]
    D -->|Yes| E[Return True]
    D -->|No| F[Return False]
    E --> G[Display result]
    F --> G
    G --> H[End]

• String cleaning: Removes spaces, converts to lowercase
• Comparison: Checks against reversed string
• Example palindromes: “radar”, “madam”, “A man a plan a canal Panama”

Mnemonic: “Clean, Reverse, Compare”

Question 5(a) [3 marks]

#

Define class and object with example.

Answer:

Class: A blueprint for creating objects that defines attributes and methods.

Object: An instance of a class with specific attribute values.

Code Example:

# Class definition
class Dog:
    # Class attribute
    species = "Canis familiaris"
    
    # Constructor (initializes instance attributes)
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    # Instance method
    def bark(self):
        return f"{self.name} says Woof!"

# Creating objects (instances)
dog1 = Dog("Rex", 3)
dog2 = Dog("Buddy", 5)

# Accessing attributes and methods
print(dog1.name)  # Output: Rex
print(dog2.species)  # Output: Canis familiaris
print(dog1.bark())  # Output: Rex says Woof!

Class-Object Relationship:

classDiagram
    class Dog {
        +species: string
        +name: string
        +age: int
        +__init__(name, age)
        +bark()
    }
    Dog <|-- dog1
    Dog <|-- dog2
    class dog1 {
        name = "Rex"
        age = 3
    }
    class dog2 {
        name = "Buddy"
        age = 5
    }

• Class: Template with attributes and methods
• Object: Concrete instance with specific values

Mnemonic: “CAMBO” (Classes Are Molds, Build Objects)

Question 5(b) [4 marks]

#

Classify constructor. Explain any one in detail.

Answer:

Parameterized Constructor Example:

class Student:
    # Parameterized constructor
    def __init__(self, name, roll_no, marks):
        self.name = name
        self.roll_no = roll_no
        self.marks = marks
        
    def display(self):
        print(f"Name: {self.name}, Roll No: {self.roll_no}, Marks: {self.marks}")

# Creating objects with parameters
student1 = Student("Alice", 101, 85)
student2 = Student("Bob", 102, 78)

# Displaying student information
student1.display()  # Output: Name: Alice, Roll No: 101, Marks: 85
student2.display()  # Output: Name: Bob, Roll No: 102, Marks: 78

Constructor Flow:

flowchart TD
    A[Create Student object] --> B[__init__ called]
    B --> C[Initialize name attribute]
    C --> D[Initialize roll_no attribute]
    D --> E[Initialize marks attribute]
    E --> F[Object ready to use]

• Purpose: Initialize object attributes
• Self parameter: Reference to the instance being created
• Automatic call: Called when object is created

Mnemonic: “PICAN” (Parameters Initialize Constructor And Name)

Question 5(c) [7 marks]

#

Develop and explain a python code to implement hierarchical inheritance.

Answer:

# Base class
class Vehicle:
    def __init__(self, make, model, year):
        self.make = make
        self.model = model
        self.year = year
    
    def display_info(self):
        return f"{self.year} {self.make} {self.model}"
    
    def start_engine(self):
        return "Engine started!"

# Derived class 1
class Car(Vehicle):
    def __init__(self, make, model, year, doors):
        # Call parent class constructor
        super().__init__(make, model, year)
        self.doors = doors
    
    def drive(self):
        return "Car is being driven!"

# Derived class 2
class Motorcycle(Vehicle):
    def __init__(self, make, model, year, has_sidecar):
        # Call parent class constructor
        super().__init__(make, model, year)
        self.has_sidecar = has_sidecar
    
    def wheelie(self):
        if not self.has_sidecar:
            return "Performing wheelie!"
        else:
            return "Cannot perform wheelie with sidecar!"

# Create objects
car = Car("Toyota", "Corolla", 2023, 4)
motorcycle = Motorcycle("Honda", "CBR", 2024, False)

# Use methods from parent class
print(car.display_info())  # Output: 2023 Toyota Corolla
print(motorcycle.start_engine())  # Output: Engine started!

# Use methods from specific classes
print(car.drive())  # Output: Car is being driven!
print(motorcycle.wheelie())  # Output: Performing wheelie!

Hierarchical Inheritance Diagram:

classDiagram
    Vehicle <|-- Car
    Vehicle <|-- Motorcycle

    class Vehicle {
        +make
        +model
        +year
        +__init__(make, model, year)
        +display_info()
        +start_engine()
    }
    
    class Car {
        +doors
        +__init__(make, model, year, doors)
        +drive()
    }
    
    class Motorcycle {
        +has_sidecar
        +__init__(make, model, year, has_sidecar)
        +wheelie()
    }

• Base class: Common attributes/methods for all vehicles
• Derived classes: Specialized behaviors for specific vehicle types
• Method inheritance: Child classes inherit parent class methods

Mnemonic: “Parents Share, Children Specialize”

Question 5(a) OR [3 marks]

#

What is the init method in Python? Explain its purpose with a suitable example.

Answer:

The __init__ method is a special method (constructor) in Python classes that is automatically called when an object is created.

Purpose:

1. Initialize object attributes
2. Set up the initial state of the object
3. Execute code that must run when object is created

Example:

class Rectangle:
    def __init__(self, length, width):
        # Initialize attributes
        self.length = length
        self.width = width
        self.area = length * width  # Calculated attribute
        
        # Print confirmation message
        print(f"Rectangle created with dimensions {length}x{width}")
    
    def display(self):
        return f"Rectangle: {self.length}x{self.width}, Area: {self.area}"

# Create rectangle objects
rect1 = Rectangle(5, 3)  # __init__ called automatically
rect2 = Rectangle(10, 2)  # __init__ called automatically

# Display information
print(rect1.display())
print(rect2.display())

• Automatic execution: Called when object is created
• Self parameter: References the current instance
• Multiple parameters: Can accept any number of arguments

Mnemonic: “ASAP” (Attributes Set At Production)

Question 5(b) OR [4 marks]

#

Classify methods in Python class. Explain any one in detail.

Answer:

Instance Method Example:

class Student:
    # Class variable
    school = "ABC School"
    
    def __init__(self, name, age):
        # Instance variables
        self.name = name
        self.age = age
    
    # Instance method - operates on instance
    def display_info(self):
        return f"Name: {self.name}, Age: {self.age}, School: {self.school}"
    
    # Instance method with parameter
    def is_eligible(self, min_age):
        return self.age >= min_age

# Create object
student = Student("John", 15)

# Call instance methods
print(student.display_info())  # Output: Name: John, Age: 15, School: ABC School
print(student.is_eligible(16))  # Output: False

Method Classification:

classDiagram
    class Student {
        +name: string
        +age: int
        +school: string
        +__init__(name, age)
        +display_info()
        +is_eligible(min_age)
        +@classmethod create_from_birth_year(cls, name, birth_year)
        +@staticmethod validate_name(name)
    }

• Instance methods: Access and modify object state
• Self parameter: Reference to the instance
• Object-specific: Results depend on the instance state

Mnemonic: “SIAM” (Self Is Always Mentioned in instance methods)

Question 5(c) OR [7 marks]

#

Develop a Python code for Polymorphism and explain it.

Answer:

# Base class
class Animal:
    def __init__(self, name):
        self.name = name
    
    def make_sound(self):
        # Generic sound - will be overridden by subclasses
        return "Some generic sound"

# Derived class 1
class Dog(Animal):
    def make_sound(self):
        # Override base class method
        return "Woof!"

# Derived class 2
class Cat(Animal):
    def make_sound(self):
        # Override base class method
        return "Meow!"

# Derived class 3
class Cow(Animal):
    def make_sound(self):
        # Override base class method
        return "Moo!"

# Function using polymorphism
def animal_sound(animal):
    # Same function works for any Animal subclass
    return animal.make_sound()

# Create objects of different classes
dog = Dog("Rex")
cat = Cat("Whiskers")
cow = Cow("Daisy")

# Demonstrate polymorphism
animals = [dog, cat, cow]
for animal in animals:
    print(f"{animal.name} says: {animal_sound(animal)}")

# Output:
# Rex says: Woof!
# Whiskers says: Meow!
# Daisy says: Moo!

Polymorphism Diagram:

classDiagram
    Animal <|-- Dog
    Animal <|-- Cat
    Animal <|-- Cow

    class Animal {
        +name: string
        +__init__(name)
        +make_sound()
    }
    
    class Dog {
        +make_sound()
    }
    
    class Cat {
        +make_sound()
    }
    
    class Cow {
        +make_sound()
    }

• Method overriding: Subclasses implement their own versions
• Single interface: Same method name for different behavior
• Flexibility: Code works with any class in the hierarchy
• Dynamic binding: Correct method called based on object type

Mnemonic: “Same Method, Different Behavior”