OOPS & Python Programming (4351108) - Winter 2024 Solution

# Numeric types
age = 25          # int
price = 99.99     # float

# Text type
name = "Python"   # str

# Boolean type
is_valid = True   # bool

# Collection types
numbers = [1, 2, 3]        # list
coordinates = (10, 20)     # tuple
student = {"name": "John"} # dict
unique_ids = {1, 2, 3}     # set

# Arithmetic
a = 10 + 5    # 15
b = 10 // 3   # 3

# Assignment
x = 5
x += 3        # x becomes 8

# Identity
list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(list1 is list2)      # False
print(list1 is not list2)  # True

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

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

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

num1, num2, num3 = map(float, input("Enter 3 numbers: ").split())
maximum = max(num1, num2, num3)
print(f"Maximum: {maximum}")

# Create empty dictionary
student = {}

# Add elements
student['name'] = 'John'
student['age'] = 20
student['grade'] = 'A'

# Modify element
student['age'] = 21

# Delete element
del student['grade']

# Display dictionary
print(student)  # Output: {'name': 'John', 'age': 21}

# Other methods
student.pop('age')           # Remove and return value
student.update({'city': 'Mumbai'})  # Add multiple items

# Pattern program
for i in range(1, 6):
    for j in range(1, i + 1):
        print(j, end=" ")
    print()  # New line after each row

# Input number from user
number = int(input("Enter a number: "))
original_number = number
sum_digits = 0

# Extract and sum digits
while number > 0:
    digit = number % 10    # Get last digit
    sum_digits += digit    # Add to sum
    number = number // 10  # Remove last digit

# Display result
print(f"Sum of digits of {original_number} is: {sum_digits}")

number = input("Enter number: ")
sum_digits = sum(int(digit) for digit in number)
print(f"Sum of digits: {sum_digits}")

# Create lists
list1 = [1, 2, 3, 4, 5]
list2 = [6, 7, 8]

# Slicing operations
print(list1[1:4])    # [2, 3, 4]
print(list1[:3])     # [1, 2, 3]
print(list1[2:])     # [3, 4, 5]
print(list1[::2])    # [1, 3, 5]
print(list1[::-1])   # [5, 4, 3, 2, 1]

# Concatenation operations
result1 = list1 + list2           # [1, 2, 3, 4, 5, 6, 7, 8]
list1.extend(list2)               # Adds list2 to list1
combined = [*list1, *list2]       # Using unpacking operator

# Create list
fruits = ['apple', 'banana']

# Add element to end
fruits.append('orange')
print(fruits)  # ['apple', 'banana', 'orange']

# Method 1: Using negative index
my_tuple = (10, 20, 30, 40, 50)
last_element = my_tuple[-1]
print(last_element)  # Output: 50

# Method 2: Using length
last_element = my_tuple[len(my_tuple) - 1]
print(last_element)  # Output: 50

# Create empty set
my_set = set()

# Add elements
my_set.add(10)
my_set.add(20)

# Remove element
my_set.remove(10)

# Create two sets for operations
A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

# Union (all unique elements)
union_result = A.union(B)        # {1, 2, 3, 4, 5, 6}

# Intersection (common elements)
intersection_result = A.intersection(B)  # {3, 4}

# Difference (A - B)
difference_result = A.difference(B)      # {1, 2}

# Symmetric difference (elements in A or B, but not both)
sym_diff_result = A.symmetric_difference(B)  # {1, 2, 5, 6}

# Single quotes
name = 'Python'

# Double quotes
message = "Hello World"

# Triple quotes (multiline)
text = """This is a
multiline string"""

word = "PYTHON"
print(word[0])    # P (first character)
print(word[2])    # T (third character)
print(word[-1])   # N (last character)
print(word[-2])   # O (second last)

numbers = [10, 20, 30, 40, 50]

# Method 1: Direct iteration
for num in numbers:
    print(num)

# Method 2: Using index
for i in range(len(numbers)):
    print(f"Index {i}: {numbers[i]}")

numbers = [10, 20, 30, 40, 50]
i = 0

while i < len(numbers):
    print(f"Element at index {i}: {numbers[i]}")
    i += 1

# Input number of students
n = int(input("Enter number of students: "))

# Create empty dictionary
students = {}

# Input student data
for i in range(n):
    print(f"\nEnter details for student {i + 1}:")
    roll_no = int(input("Roll number: "))
    name = input("Name: ")
    marks = float(input("Marks: "))
    
    # Store in dictionary
    students[roll_no] = {
        'name': name,
        'marks': marks
    }

# Display students with marks above 75
print("\nStudents with marks above 75:")
print("-" * 30)

high_performers = []
for roll_no, data in students.items():
    if data['marks'] > 75:
        high_performers.append(data['name'])
        print(f"Name: {data['name']}, Marks: {data['marks']}")

if not high_performers:
    print("No student scored above 75 marks")
else:
    print(f"\nTotal high performers: {len(high_performers)}")

import random

# random() - generates float between 0.0 and 1.0
num = random.random()
print(num)  # Example: 0.7234567

# randint() - generates integer between given range
dice = random.randint(1, 6)
print(dice)  # Example: 4

# choice() - selects random element from sequence
colors = ['red', 'blue', 'green']
selected = random.choice(colors)
print(selected)  # Example: 'blue'

# Without function (repetitive)
num1 = 5
square1 = num1 * num1
print(square1)

num2 = 8
square2 = num2 * num2
print(square2)

# With function (reusable)
def calculate_square(num):
    return num * num

print(calculate_square(5))  # 25
print(calculate_square(8))  # 64

# Input string from user
text = input("Enter a string: ")

# Find all positions of 'a'
positions = []
for i in range(len(text)):
    if text[i].lower() == 'a':  # Check for both 'a' and 'A'
        positions.append(i)

# Display results
if positions:
    print(f"Character 'a' found at positions: {positions}")
    print("Detailed locations:")
    for pos in positions:
        print(f"Position {pos}: '{text[pos]}'")
else:
    print("Character 'a' not found in the string")

# Alternative method using enumerate
print("\nAlternative approach:")
for index, char in enumerate(text):
    if char.lower() == 'a':
        print(f"'a' found at position {index}")

text = input("Enter a string: ")
count = 0

print(f"Searching for 'a' in: '{text}'")
print("-" * 30)

for i, char in enumerate(text):
    if char.lower() == 'a':
        count += 1
        print(f"Found 'a' at index {i} (character: '{char}')")

print(f"\nTotal occurrences of 'a': {count}")

# Global variable
global_var = "I am global"

def my_function():
    # Local variable
    local_var = "I am local"
    print(global_var)  # Can access global
    print(local_var)   # Can access local

my_function()
print(global_var)      # Can access global
# print(local_var)     # Error - cannot access local

counter = 0  # Global variable

def increment():
    global counter  # Declare as global to modify
    counter += 1

increment()
print(counter)  # Output: 1

def function_name(parameters):
    """Optional docstring"""
    # Function body
    return value  # Optional

# Function definition
def greet_user(name, age):
    """Function to greet user with name and age"""
    message = f"Hello {name}! You are {age} years old."
    return message

# Function call
user_name = "John"
user_age = 25
greeting = greet_user(user_name, user_age)
print(greeting)  # Output: Hello John! You are 25 years old.

# Function with default parameter
def calculate_power(base, exponent=2):
    return base ** exponent

print(calculate_power(5))     # 25 (using default exponent=2)
print(calculate_power(5, 3))  # 125 (using exponent=3)

def calcFact(number):
    """
    Function to calculate factorial of a number
    Input: number (integer)
    Output: factorial (integer)
    """
    if number < 0:
        return "Factorial is not defined for negative numbers"
    elif number == 0 or number == 1:
        return 1
    else:
        factorial = 1
        for i in range(2, number + 1):
            factorial *= i
        return factorial

# Main program
try:
    # Input from user
    num = int(input("Enter a number: "))
    
    # Call function
    result = calcFact(num)
    
    # Display result
    if isinstance(result, str):
        print(result)
    else:
        print(f"Factorial of {num} is: {result}")
        
except ValueError:
    print("Please enter a valid integer")

# Test with multiple values
print("\nTesting with different values:")
test_values = [0, 1, 5, 10, -3]
for val in test_values:
    result = calcFact(val)
    print(f"calcFact({val}) = {result}")

def calcFactRecursive(n):
    """Recursive function to calculate factorial"""
    if n < 0:
        return "Undefined for negative numbers"
    elif n == 0 or n == 1:
        return 1
    else:
        return n * calcFactRecursive(n - 1)

# Example usage
number = int(input("Enter number: "))
result = calcFactRecursive(number)
print(f"Factorial: {result}")

# Class definition (blueprint)
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# Object creation (instances)
student1 = Student("John", 20)  # Object 1
student2 = Student("Alice", 19) # Object 2

print(student1.name)  # John
print(student2.name)  # Alice

class Rectangle:
    def __init__(self, length=0, width=0):  # Constructor
        self.length = length  # Initialize attribute
        self.width = width    # Initialize attribute
        print("Rectangle object created!")
    
    def area(self):
        return self.length * self.width

# Object creation - constructor called automatically
rect1 = Rectangle(10, 5)  # Output: Rectangle object created!
rect2 = Rectangle()       # Uses default values

print(rect1.area())       # 50
print(rect2.area())       # 0

class Student:
    def __init__(self, name, roll_number, marks):
        """Constructor to initialize student attributes"""
        self.name = name
        self.roll_number = roll_number
        self.marks = marks
    
    def display_info(self):
        """Method to display student information"""
        print("-" * 30)
        print("STUDENT INFORMATION")
        print("-" * 30)
        print(f"Name: {self.name}")
        print(f"Roll Number: {self.roll_number}")
        print(f"Marks: {self.marks}")
        print("-" * 30)
    
    def calculate_grade(self):
        """Method to calculate grade based on marks"""
        if self.marks >= 90:
            return 'A+'
        elif self.marks >= 80:
            return 'A'
        elif self.marks >= 70:
            return 'B'
        elif self.marks >= 60:
            return 'C'
        else:
            return 'F'
    
    def display_grade(self):
        """Method to display grade"""
        grade = self.calculate_grade()
        print(f"Grade: {grade}")

# Creating objects of Student class
print("Creating Student Objects:")
student1 = Student("John Doe", 101, 85)
student2 = Student("Alice Smith", 102, 92)
student3 = Student("Bob Johnson", 103, 78)

# Using methods to display information
print("\n=== Student 1 Details ===")
student1.display_info()
student1.display_grade()

print("\n=== Student 2 Details ===")
student2.display_info()
student2.display_grade()

print("\n=== Student 3 Details ===")
student3.display_info()
student3.display_grade()

# Accessing attributes directly
print(f"\nDirect access - Student 1 name: {student1.name}")
print(f"Direct access - Student 2 marks: {student2.marks}")

class BankAccount:
    def __init__(self, balance):
        self.__balance = balance  # Private attribute
    
    def get_balance(self):       # Getter method
        return self.__balance
    
    def deposit(self, amount):   # Controlled access
        if amount > 0:
            self.__balance += amount

account = BankAccount(1000)
print(account.get_balance())     # 1000
# print(account.__balance)       # Error - cannot access directly

# Level 1 - Base class
class Vehicle:
    def __init__(self, brand):
        self.brand = brand
    
    def start(self):
        print(f"{self.brand} vehicle started")

# Level 2 - Inherits from Vehicle
class Car(Vehicle):
    def __init__(self, brand, model):
        super().__init__(brand)
        self.model = model
    
    def drive(self):
        print(f"{self.brand} {self.model} is driving")

# Level 3 - Inherits from Car
class SportsCar(Car):
    def __init__(self, brand, model, top_speed):
        super().__init__(brand, model)
        self.top_speed = top_speed
    
    def race(self):
        print(f"{self.brand} {self.model} racing at {self.top_speed} km/h")

# Creating object and using methods
ferrari = SportsCar("Ferrari", "F8", 340)
ferrari.start()    # From Vehicle class
ferrari.drive()    # From Car class
ferrari.race()     # From SportsCar class

# Base class
class Animal:
    def __init__(self, name):
        self.name = name
        print(f"Animal {self.name} created")
    
    def eat(self):
        print(f"{self.name} is eating")
    
    def sleep(self):
        print(f"{self.name} is sleeping")

# Single inheritance from Animal
class Mammal(Animal):
    def __init__(self, name, fur_color):
        super().__init__(name)
        self.fur_color = fur_color
    
    def give_birth(self):
        print(f"{self.name} gives birth to live babies")

# Single inheritance from Animal
class Bird(Animal):
    def __init__(self, name, wing_span):
        super().__init__(name)
        self.wing_span = wing_span
    
    def fly(self):
        print(f"{self.name} is flying with {self.wing_span}cm wings")
    
    def lay_eggs(self):
        print(f"{self.name} lays eggs")

# Single inheritance from Mammal
class Dog(Mammal):
    def __init__(self, name, fur_color, breed):
        super().__init__(name, fur_color)
        self.breed = breed
    
    def bark(self):
        print(f"{self.name} the {self.breed} is barking")
    
    def guard(self):
        print(f"{self.name} is guarding the house")

# Multiple inheritance from Dog and Bird (Hybrid)
class FlyingDog(Dog, Bird):
    def __init__(self, name, fur_color, breed, wing_span):
        # Initialize both parent classes
        Dog.__init__(self, name, fur_color, breed)
        Bird.__init__(self, name, wing_span)
        print(f"Magical {self.name} created with both mammal and bird features!")
    
    def fly_and_bark(self):
        print(f"{self.name} is flying and barking at the same time!")
    
    def show_abilities(self):
        print(f"\n{self.name}'s Abilities:")
        print("-" * 25)
        self.eat()          # From Animal
        self.sleep()        # From Animal
        self.give_birth()   # From Mammal
        self.bark()         # From Dog
        self.guard()        # From Dog
        self.fly()          # From Bird
        self.lay_eggs()     # From Bird
        self.fly_and_bark() # Own method

# Demonstration
print("=== Hybrid Inheritance Demo ===\n")

# Create objects
print("1. Creating regular dog:")
dog1 = Dog("Buddy", "Golden", "Retriever")
dog1.bark()
dog1.guard()

print("\n2. Creating regular bird:")
bird1 = Bird("Eagle", 200)
bird1.fly()
bird1.lay_eggs()

print("\n3. Creating magical flying dog:")
flying_dog = FlyingDog("Superdog", "Silver", "Husky", 150)
flying_dog.show_abilities()

# Method Resolution Order
print(f"\nMethod Resolution Order for FlyingDog:")
for i, cls in enumerate(FlyingDog.__mro__):
    print(f"{i+1}. {cls.__name__}")