Practice Questions — Object-Oriented Programming in Python

class Student:
    def __init__(self, name, marks=None):
        self.name = name
        self.marks = marks if marks else []
    
    def add_mark(self, mark):
        self.marks.append(mark)
    
    def average(self):
        return sum(self.marks) / len(self.marks) if self.marks else 0
    
    def highest(self):
        return max(self.marks) if self.marks else 0
    
    def lowest(self):
        return min(self.marks) if self.marks else 0
    
    def __str__(self):
        return f"{self.name} - Avg: {self.average():.1f}, Highest: {self.highest()}, Lowest: {self.lowest()}"

s1 = Student("Aarav", [88, 92, 82, 95, 86])
s2 = Student("Priya", [91, 97, 85, 88, 94])
print(s1)
print(s2)

class BankAccount:
    total_accounts = 0
    
    def __init__(self, owner, balance=0):
        self.owner = owner
        self.balance = balance
        self.transactions = []
        BankAccount.total_accounts += 1
    
    def deposit(self, amount):
        if amount > 0:
            self.balance += amount
            self.transactions.append(f'+{amount}')
    
    def withdraw(self, amount):
        if amount > self.balance:
            print(f"Insufficient funds for {self.owner}")
            return
        if amount > 0:
            self.balance -= amount
            self.transactions.append(f'-{amount}')
    
    def show_history(self):
        return self.transactions

a1 = BankAccount("Aarav", 0)
a1.deposit(500)
a1.withdraw(200)
a1.deposit(1000)

a2 = BankAccount("Priya", 500)

print(f"{a1.owner}'s balance: {a1.balance}")
print(f"Transactions: {a1.show_history()}")
print(f"Total accounts: {BankAccount.total_accounts}")

class TodoList:
    def __init__(self):
        self.tasks = []
    
    def add(self, task):
        self.tasks.append({'task': task, 'done': False})
    
    def complete(self, index):
        if 0 <= index < len(self.tasks):
            self.tasks[index]['done'] = True
    
    def remove(self, index):
        if 0 <= index < len(self.tasks):
            self.tasks.pop(index)
    
    def pending(self):
        return [t for t in self.tasks if not t['done']]
    
    def __str__(self):
        lines = []
        for t in self.tasks:
            status = 'x' if t['done'] else ' '
            lines.append(f"[{status}] {t['task']}")
        return '\n'.join(lines)

todo = TodoList()
todo.add("Buy groceries")
todo.add("Study Python")
todo.add("Exercise")
todo.complete(0)
print(todo)
print(f"Pending: {len(todo.pending())} tasks")

def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

class Fraction:
    def __init__(self, num, den):
        if den == 0:
            raise ValueError("Denominator cannot be zero")
        if den < 0:
            num, den = -num, -den
        common = gcd(abs(num), abs(den))
        self.num = num // common
        self.den = den // common
    
    def add(self, other):
        new_num = self.num * other.den + other.num * self.den
        new_den = self.den * other.den
        return Fraction(new_num, new_den)
    
    def multiply(self, other):
        return Fraction(self.num * other.num, self.den * other.den)
    
    def __eq__(self, other):
        return self.num == other.num and self.den == other.den
    
    def __str__(self):
        return f"{self.num}/{self.den}"

a = Fraction(1, 2)
b = Fraction(1, 3)
print(f"{a} + {b} = {a.add(b)}")

c = Fraction(2, 3)
d = Fraction(3, 4)
print(f"{c} * {d} = {c.multiply(d)}")

print(f"2/4 == 1/2: {Fraction(2, 4) == Fraction(1, 2)}")

class Product:
    def __init__(self, name, price, quantity):
        self.name = name
        self.price = price
        self.quantity = quantity
    
    def __str__(self):
        return f"{self.name} - Rs.{self.price} x {self.quantity}"

class Inventory:
    def __init__(self):
        self.products = []
    
    def add_product(self, product):
        self.products.append(product)
    
    def remove_product(self, name):
        self.products = [p for p in self.products if p.name != name]
    
    def find_product(self, name):
        for p in self.products:
            if p.name == name:
                return p
        return None
    
    def total_value(self):
        return sum(p.price * p.quantity for p in self.products)
    
    def low_stock(self, threshold=10):
        return [p.name for p in self.products if p.quantity < threshold]

inv = Inventory()
inv.add_product(Product("Keyboard", 500, 15))
inv.add_product(Product("Mouse", 250, 5))
inv.add_product(Product("Monitor", 8000, 1))

print(f"Total value: Rs.{inv.total_value()}")
print(f"Low stock (< 10): {inv.low_stock(10)}")
print(f"Found: {inv.find_product('Keyboard')}")

class Song:
    def __init__(self, title, artist, duration_seconds):
        self.title = title
        self.artist = artist
        self.duration = duration_seconds
    
    def formatted_duration(self):
        minutes = self.duration // 60
        seconds = self.duration % 60
        return f"{minutes}:{seconds:02d}"
    
    def __str__(self):
        return f"{self.title} - {self.artist} ({self.formatted_duration()})"

class Playlist:
    def __init__(self, name):
        self.name = name
        self.songs = []
    
    def add(self, song):
        self.songs.append(song)
    
    def remove(self, title):
        self.songs = [s for s in self.songs if s.title != title]
    
    def total_duration(self):
        total = sum(s.duration for s in self.songs)
        minutes = total // 60
        seconds = total % 60
        return f"{minutes}:{seconds:02d}"
    
    def __str__(self):
        lines = [f"{i+1}. {song}" for i, song in enumerate(self.songs)]
        return '\n'.join(lines)

pl = Playlist("Favorites")
pl.add(Song("Shape of You", "Ed Sheeran", 233))
pl.add(Song("Believer", "Imagine Dragons", 204))
pl.add(Song("Blinding Lights", "The Weeknd", 200))
print(pl)
print(f"Total duration: {pl.total_duration()}")

class Vector2D:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    
    def __add__(self, other):
        return Vector2D(self.x + other.x, self.y + other.y)
    
    def __sub__(self, other):
        return Vector2D(self.x - other.x, self.y - other.y)
    
    def __mul__(self, scalar):
        return Vector2D(self.x * scalar, self.y * scalar)
    
    def __abs__(self):
        return (self.x**2 + self.y**2) ** 0.5
    
    def __eq__(self, other):
        if not isinstance(other, Vector2D):
            return NotImplemented
        return self.x == other.x and self.y == other.y
    
    def __str__(self):
        return f"({self.x}, {self.y})"
    
    def __repr__(self):
        return f"Vector2D({self.x}, {self.y})"

v1 = Vector2D(1, 2)
v2 = Vector2D(3, 4)

print(f"v1 + v2 = {v1 + v2}")
print(f"v1 - v2 = {v1 - v2}")
print(f"v1 * 3 = {v1 * 3}")
print(f"|v2| = {abs(v2)}")
print(f"v1 == Vector2D(1, 2): {v1 == Vector2D(1, 2)}")

class Node:
    def __init__(self, value):
        self.value = value
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None
    
    def append(self, value):
        new_node = Node(value)
        if not self.head:
            self.head = new_node
            return
        current = self.head
        while current.next:
            current = current.next
        current.next = new_node
    
    def prepend(self, value):
        new_node = Node(value)
        new_node.next = self.head
        self.head = new_node
    
    def delete(self, value):
        if not self.head:
            return
        if self.head.value == value:
            self.head = self.head.next
            return
        current = self.head
        while current.next:
            if current.next.value == value:
                current.next = current.next.next
                return
            current = current.next
    
    def search(self, value):
        current = self.head
        while current:
            if current.value == value:
                return True
            current = current.next
        return False
    
    def length(self):
        count = 0
        current = self.head
        while current:
            count += 1
            current = current.next
        return count
    
    def __str__(self):
        parts = []
        current = self.head
        while current:
            parts.append(str(current.value))
            current = current.next
        parts.append("None")
        return " -> ".join(parts)

ll = LinkedList()
for v in [1, 2, 3, 4]:
    ll.append(v)
print(ll)
print(f"Length: {ll.length()}")
print(f"Search 3: {ll.search(3)}")
ll.delete(2)
print(f"After delete 2: {ll}")

class Shape:
    _registry = {}
    
    @classmethod
    def register(cls, shape_type, shape_class):
        cls._registry[shape_type] = shape_class
    
    @classmethod
    def from_dict(cls, data):
        shape_type = data.get('type')
        shape_class = cls._registry.get(shape_type)
        if not shape_class:
            raise ValueError(f"Unknown shape: {shape_type}")
        return shape_class(**{k: v for k, v in data.items() if k != 'type'})
    
    @classmethod
    def registered_shapes(cls):
        return list(cls._registry.keys())

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return round(3.14159 * self.radius ** 2, 2)
    
    def __str__(self):
        return f"Circle(radius={self.radius})"

class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height
    
    def __str__(self):
        return f"Rectangle({self.width}x{self.height})"

Shape.register('circle', Circle)
Shape.register('rectangle', Rectangle)

c = Shape.from_dict({'type': 'circle', 'radius': 5})
r = Shape.from_dict({'type': 'rectangle', 'width': 4, 'height': 6})
print(f"{c} area: {c.area()}")
print(f"{r} area: {r.area()}")
print(f"Registered shapes: {Shape.registered_shapes()}")