30+ Python Object-Oriented Programming (OOP) Exercise: Classes and Objects Exercises

This article provides 31 Python Object-Oriented Programming (OOP) practice questions with solutions.

These exercises cover classes, attributes, methods, logic, inheritance, polymorphism, magic methods, encapsulation, type checking, and advance OOP concepts.

Each coding challenge includes a Practice Problem, Hint, Solution code, and detailed Explanation, ensuring you don’t just copy code, but genuinely practice and understand how and why it works.

• All solutions have been fully tested on Python 3.
• Use our Online Code Editor to solve these exercises in real time.
• If you have other solutions, please share them in the comments to help fellow developers.

Exercise 1: Define an Empty Vehicle Class

Problem Statement: Write a Python program to create a class named Vehicle that has no variables or methods defined inside it.

Purpose: This exercise introduces the most basic form of a Python class definition. It teaches you the required syntax for declaring a class and the use of the pass keyword as a placeholder, which is essential when you want to define an empty class or function body without causing a syntax error.

Given Input: No input required.

Expected Output: <class '__main__.Vehicle'>

Refer: Classes and Objects in Python

class Vehicle:
    pass

print(Vehicle)Code language: Python (python)

Exercise 2: Vehicle Class with Instance Attributes

Problem Statement: Write a Python program to create a Vehicle class with two instance attributes: max_speed and mileage. Create an object of the class and print both attributes.

Purpose: Learn to define instance attributes using the __init__ constructor method. Instance attributes are unique to each object, meaning different Vehicle objects can hold different values for speed and mileage. This is a foundational concept in object-oriented programming.

Given Input: vehicle1 = Vehicle("Tesla Model S", 250, 18)

Expected Output: Vehicle Name: Tesla Model S, Speed: 250, Mileage: 18

Refer:

• Instance variables in Python
• Python Instance Methods
• Constructors in Python

class Vehicle:
    def __init__(self, name, max_speed, mileage):
        self.name = name
        self.max_speed = max_speed
        self.mileage = mileage

vehicle1 = Vehicle("Tesla Model S", 250, 18)
print(f"Vehicle Name: {vehicle1.name}, Speed: {vehicle1.max_speed}, Mileage: {vehicle1.mileage}")Code language: Python (python)

Exercise 3: Rectangle Class with Area & Perimeter

Problem Statement: Write a Python program to create a Rectangle class with length and width as instance attributes, and two methods: area() that returns the area and perimeter() that returns the perimeter.

Purpose: Learn how to add instance methods to a class. Methods allow objects to perform operations using their own data, which is a key principle of encapsulation in OOP. Calculating geometric properties is a clean, practical context for understanding how self connects methods to instance data.

Given Input: rect = Rectangle(10, 4)

Expected Output: Area = 40 and Perimeter = 28

class Rectangle:
    def __init__(self, length, width):
        self.length = length
        self.width = width

    def area(self):
        return self.length * self.width

    def perimeter(self):
        return 2 * (self.length + self.width)

rect = Rectangle(10, 4)
print("Area =", rect.area())
print("Perimeter =", rect.perimeter())Code language: Python (python)

Exercise 4: Student Class with Average Grade

Problem Statement: Write a Python program to create a Student class that stores a student’s name and a list of marks. Add a method average() that calculates and returns the average of all marks.

Purpose: This exercise shows how instance attributes can store complex data types such as lists, not just simple values. It also practices combining OOP with list operations and arithmetic, a pattern common in gradebooks, dashboards, and reporting tools.

Given Input: s1 = Student("Alice", [85, 90, 78, 92, 88])

Expected Output: Alice's Average Grade: 86.6

class Student:
    def __init__(self, name, marks):
        self.name = name
        self.marks = marks

    def average(self):
        return sum(self.marks) / len(self.marks)

s1 = Student("Alice", [85, 90, 78, 92, 88])
print(f"{s1.name}'s Average Grade: {s1.average()}")Code language: Python (python)

Exercise 5: Product Class with Stock Value Calculator

Problem Statement: Write a Python program to create a Product class with three instance attributes: name, price, and quantity. Add a method total_value() that returns the total stock value by multiplying price by quantity.

Purpose: This exercise models a real-world business scenario using OOP. It reinforces how instance methods can derive new information from existing attributes, a pattern widely used in inventory management, e-commerce, and financial applications.

Given Input: p1 = Product("Laptop", 899.99, 5)

Expected Output: Total stock value of Laptop: $4499.95

class Product:
    def __init__(self, name, price, quantity):
        self.name = name
        self.price = price
        self.quantity = quantity

    def total_value(self):
        return self.price * self.quantity

p1 = Product("Laptop", 899.99, 5)
print(f"Total stock value of {p1.name}: ${p1.total_value():.2f}")Code language: Python (python)

Exercise 6: Bank Account with Deposit & Overdraw Protection

Problem Statement: Write a Python program to create a BankAccount class with a balance attribute and two methods: deposit(amount) that adds funds to the balance, and withdraw(amount) that deducts funds but prevents the balance from going below zero.

Purpose: Learn data validation and conditional logic inside instance methods. Preventing overdraw is a real-world business rule, and implementing it here teaches you how classes can enforce constraints on their own data, a core idea behind encapsulation in OOP.

Given Input: Starting balance of 1000, deposit 500, withdraw 200, then attempt to withdraw 2000.

Expected Output:

Balance after deposit: 1500
Balance after withdrawal: 1300
Insufficient funds. Current balance: 1300

class BankAccount:
    def __init__(self, balance):
        self.balance = balance
    def deposit(self, amount):
        self.balance += amount
        print(f"Balance after deposit: {self.balance}")
    def withdraw(self, amount):
        if amount <= self.balance:
            self.balance -= amount
            print(f"Balance after withdrawal: {self.balance}")
        else:
            print(f"Insufficient funds. Current balance: {self.balance}")
account = BankAccount(1000)
account.deposit(500)
account.withdraw(200)
account.withdraw(2000)Code language: Python (python)

Exercise 7: Light Class with On/Off State Toggle

Problem Statement: Write a Python program to create a Light class with three methods: turn_on() that switches the light on, turn_off() that switches it off, and status() that reports whether the light is currently on or off.

Purpose: This exercise models a simple stateful object, where the object remembers and changes its own condition over time. It introduces the concept of state management within a class, a pattern found everywhere from UI components and IoT devices to game objects and workflow engines.

Given Input: Create a Light object, call turn_on(), check status(), call turn_off(), and check status() again.

Expected Output:

Light is ON
Current status: ON
Light is OFF
Current status: OFF

class Light:
    def __init__(self):
        self.is_on = False

    def turn_on(self):
        self.is_on = True
        print("Light is ON")

    def turn_off(self):
        self.is_on = False
        print("Light is OFF")

    def status(self):
        state = "ON" if self.is_on else "OFF"
        print(f"Current status: {state}")

light = Light()
light.turn_on()
light.status()
light.turn_off()
light.status()Code language: Python (python)

Exercise 8: User Class with Password Validation

Problem Statement: Write a Python program to create a User class that stores a username and a password. Add a check_password(input_password) method that returns True if the input matches the stored password, and False otherwise.

Purpose: This exercise introduces the idea of controlled access to sensitive data inside a class. Rather than exposing the password directly, the class provides a dedicated method to verify it. This pattern reflects a core principle of encapsulation in OOP, where internal data is protected and accessed only through defined interfaces.

Given Input: u1 = User("alice", "secure123")

Expected Output:

True
False

class User:
    def __init__(self, username, password):
        self.username = username
        self.password = password

    def check_password(self, input_password):
        return self.password == input_password

u1 = User("alice", "secure123")
print(u1.check_password("secure123"))
print(u1.check_password("wrongpass"))Code language: Python (python)

Exercise 9: Temperature Class with Unit Converters

Problem Statement: Write a Python program to create a Temperature class that stores a temperature in Celsius. Add two methods: to_fahrenheit() that converts and returns the value in Fahrenheit, and to_kelvin() that converts and returns the value in Kelvin.

Purpose: This exercise demonstrates how a class can act as a data container with built-in conversion logic. It reinforces writing multiple methods that all operate on the same instance attribute, and applies straightforward mathematical formulas in a practical scientific context.

Given Input: t = Temperature(100)

Expected Output:

Celsius: 100
Fahrenheit: 212.0
Kelvin: 373.15

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    def to_fahrenheit(self):
        return (self.celsius * 9 / 5) + 32

    def to_kelvin(self):
        return self.celsius + 273.15

t = Temperature(100)
print("Celsius:", t.celsius)
print("Fahrenheit:", t.to_fahrenheit())
print("Kelvin:", t.to_kelvin())Code language: Python (python)

Exercise 10: Notebook Class with Add & Display Notes

Problem Statement: Write a Python program to create a Notebook class that maintains an internal list of notes. Add an add_note(note) method that appends a new note to the list, and a show_notes() method that prints all stored notes.

Purpose: This exercise shows how a class can manage a growing collection of data over its lifetime. It practices initializing a mutable data structure inside __init__ and writing methods that both modify and read that structure, a pattern that appears in todo lists, message queues, logs, and many other applications.

Given Input: Add three notes: "Buy groceries", "Read a book", "Call the doctor".

Expected Output:

1. Buy groceries
2. Read a book
3. Call the doctor

class Notebook:
    def __init__(self):
        self.notes = []

    def add_note(self, note):
        self.notes.append(note)

    def show_notes(self):
        for i, note in enumerate(self.notes, start=1):
            print(f"{i}. {note}")

nb = Notebook()
nb.add_note("Buy groceries")
nb.add_note("Read a book")
nb.add_note("Call the doctor")
nb.show_notes()Code language: Python (python)

Exercise 11: Coffee Machine with Multi-Resource Tracking

Problem Statement: Write a Python program to create a CoffeeMachine class that tracks three resource attributes: water, coffee, and milk (in ml/g). Add a make_latte() method that checks whether sufficient resources are available, deducts them if so, and prints an appropriate message in either case.

Purpose: This exercise combines state management, resource tracking, and conditional logic inside a single class. It mirrors how real-world stateful systems (vending machines, inventory systems, game resource managers) check preconditions before executing an action and update their internal state only when the action is valid.

Given Input: CoffeeMachine(water=300, coffee=100, milk=200). A latte requires 200ml water, 20g coffee, and 150ml milk.

Expected Output:

Latte made! Remaining - Water: 100ml, Coffee: 80g, Milk: 50ml
Not enough resources to make a latte.

class CoffeeMachine:
    def __init__(self, water, coffee, milk):
        self.water = water
        self.coffee = coffee
        self.milk = milk

    def make_latte(self):
        water_needed = 200
        coffee_needed = 20
        milk_needed = 150

        if self.water >= water_needed and self.coffee >= coffee_needed and self.milk >= milk_needed:
            self.water -= water_needed
            self.coffee -= coffee_needed
            self.milk -= milk_needed
            print(f"Latte made! Remaining - Water: {self.water}ml, Coffee: {self.coffee}g, Milk: {self.milk}ml")
        else:
            print("Not enough resources to make a latte.")

machine = CoffeeMachine(water=300, coffee=100, milk=200)
machine.make_latte()
machine.make_latte()Code language: Python (python)

Exercise 12: Shared Class Attribute Across Instances

Problem Statement: Write a Python program to create a Vehicle class with a class attribute color = "White" that is shared by all instances. Create two vehicle objects and demonstrate that both share the same default color, then show that changing the class attribute updates all instances that have not overridden it.

Purpose: This exercise clarifies the distinction between class attributes and instance attributes. Class attributes are defined directly on the class and shared across every instance, making them ideal for default values or constants that apply universally. Understanding this difference prevents subtle bugs when mutable data is accidentally shared between objects.

Given Input: v1 = Vehicle("Tesla", 250) and v2 = Vehicle("BMW", 200).

Expected Output:

Tesla - Color: White, Speed: 250
BMW - Color: White, Speed: 200
Tesla - Color: Red, Speed: 250
BMW - Color: Red, Speed: 200

Refer: Python Class Variables

class Vehicle:
    color = "White"

    def __init__(self, name, max_speed):
        self.name = name
        self.max_speed = max_speed

v1 = Vehicle("Tesla", 250)
v2 = Vehicle("BMW", 200)

print(f"{v1.name} - Color: {v1.color}, Speed: {v1.max_speed}")
print(f"{v2.name} - Color: {v2.color}, Speed: {v2.max_speed}")

Vehicle.color = "Red"

print(f"{v1.name} - Color: {v1.color}, Speed: {v1.max_speed}")
print(f"{v2.name} - Color: {v2.color}, Speed: {v2.max_speed}")Code language: Python (python)

Exercise 13: Bus Subclass Inheriting from Vehicle

Problem Statement: Write a Python program to create a Vehicle parent class with name and max_speed attributes and a display() method. Then create a Bus child class that inherits everything from Vehicle without adding anything new, and confirm that an instance of Bus can access the parent’s method.

Purpose: This exercise introduces inheritance, one of the four pillars of OOP. Inheritance lets a child class automatically receive all attributes and methods from its parent, promoting code reuse and expressing natural “is-a” relationships. A Bus is a Vehicle, so it makes sense for it to share the same interface.

Given Input: bus1 = Bus("School Bus", 120)

Expected Output: Vehicle: School Bus, Max Speed: 120 km/h

Refer: Inheritance in Python

class Vehicle:
    def __init__(self, name, max_speed):
        self.name = name
        self.max_speed = max_speed

    def display(self):
        print(f"Vehicle: {self.name}, Max Speed: {self.max_speed} km/h")

class Bus(Vehicle):
    pass

bus1 = Bus("School Bus", 120)
bus1.display()Code language: Python (python)

Exercise 14: verride Parent Method Using super()

Problem Statement: Write a Python program where a Vehicle parent class has a seating_capacity() method that accepts a capacity argument. Create a Bus child class that overrides this method to provide a default seating capacity of 50, using super() to call the parent’s version internally.

Purpose: This exercise covers method overriding and the use of super(), two key tools in OOP inheritance. Overriding lets a child class customize or extend a parent method’s behavior without rewriting it from scratch. super() delegates part of the work back to the parent, keeping the code DRY and maintaining the original logic as a foundation.

Given Input: bus = Bus("School Bus", 120)

Expected Output: School Bus seating capacity is: 50

class Vehicle:
    def __init__(self, name, max_speed):
        self.name = name
        self.max_speed = max_speed

    def seating_capacity(self, capacity):
        print(f"{self.name} seating capacity is: {capacity}")

class Bus(Vehicle):
    def seating_capacity(self):
        super().seating_capacity(50)

bus = Bus("School Bus", 120)
bus.seating_capacity()Code language: Python (python)

Exercise 15: Add Maintenance Fee in Child Class via super()

Problem Statement: Write a Python program that creates a Vehicle parent class with a base fare, then extends a Taxi child class that adds a 10% maintenance fee on top of the base fare using super().

Purpose: This exercise teaches you how to use super() to call the parent class constructor, extend child class behaviour by building on inherited attributes, and model real-world pricing logic using inheritance.

Given Input: base_fare = 500

Expected Output: Total fare with maintenance fee: 550.0

class Vehicle:
    def __init__(self, base_fare):
        self.base_fare = base_fare

class Taxi(Vehicle):
    def __init__(self, base_fare):
        super().__init__(base_fare)
        self.maintenance_fee = base_fare * 0.10

    def total_fare(self):
        return self.base_fare + self.maintenance_fee

taxi = Taxi(500)
print("Total fare with maintenance fee:", taxi.total_fare())Code language: Python (python)

Exercise 16: Polymorphism with Dog & Cat speak()

Problem Statement: Write a Python program that defines an Animal base class with a speak() method, then overrides it in Dog and Cat subclasses to return their respective sounds.

Purpose: This exercise introduces method overriding, one of the core pillars of polymorphism in OOP. It shows how different subclasses can share the same interface but provide their own specific behaviour.

Given Input: Objects of Dog and Cat classes

Expected Output:

Dog says: Woof!
Cat says: Meow!

Refer: Polymorphism in Python

class Animal:
    def speak(self):
        return "Some sound"

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

dog = Dog()
cat = Cat()

print("Dog says:", dog.speak())
print("Cat says:", cat.speak())Code language: Python (python)

Exercise 17: Full-Time vs Part-Time Employee Pay Logic

Problem Statement: Write a Python program that defines an Employee base class, then creates FullTimeEmployee and PartTimeEmployee subclasses, each implementing different pay calculation logic.

Purpose: This exercise models a common HR scenario and teaches you how to use inheritance to share common attributes while allowing each subclass to define its own business logic for calculating pay.

Given Input: FullTimeEmployee("Alice", 60000) and PartTimeEmployee("Bob", 500, 20)

Expected Output:

Alice's monthly pay: 5000.0
Bob's monthly pay: 10000

class Employee:
    def __init__(self, name):
        self.name = name

    def calculate_pay(self):
        return 0

class FullTimeEmployee(Employee):
    def __init__(self, name, annual_salary):
        super().__init__(name)
        self.annual_salary = annual_salary

    def calculate_pay(self):
        return self.annual_salary / 12

class PartTimeEmployee(Employee):
    def __init__(self, name, hourly_rate, hours_worked):
        super().__init__(name)
        self.hourly_rate = hourly_rate
        self.hours_worked = hours_worked

    def calculate_pay(self):
        return self.hourly_rate * self.hours_worked

ft = FullTimeEmployee("Alice", 60000)
pt = PartTimeEmployee("Bob", 500, 20)

print(f"{ft.name}'s monthly pay: {ft.calculate_pay()}")
print(f"{pt.name}'s monthly pay: {pt.calculate_pay()}")Code language: Python (python)

Exercise 18: Shape Subclasses with Custom area() Methods

Problem Statement: Write a Python program that defines a Shape base class with an area() method, then implements it in Circle, Square, and Triangle subclasses using the appropriate geometric formulas.

Purpose: This exercise is a classic demonstration of polymorphism. Each shape shares the same area() interface but provides a completely different calculation, showing how OOP handles real-world variation cleanly.

Given Input: Circle(7), Square(4), Triangle(6, 8)

Expected Output:

Circle area: 153.94
Square area: 16
Triangle area: 24.0

class Shape:
    def area(self):
        return 0

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius

    def area(self):
        return round(3.14159 * self.radius ** 2, 2)

class Square(Shape):
    def __init__(self, side):
        self.side = side

    def area(self):
        return self.side ** 2

class Triangle(Shape):
    def __init__(self, base, height):
        self.base = base
        self.height = height

    def area(self):
        return 0.5 * self.base * self.height

shapes = [Circle(7), Square(4), Triangle(6, 8)]
for shape in shapes:
    print(f"{type(shape).__name__} area: {shape.area()}")Code language: Python (python)

Exercise 19: Media Subclasses with Type-Specific Attributes

Problem Statement: Write a Python program that defines a Media base class, then creates Book, Magazine, and DVD subclasses, each with type-specific attributes and a describe() method.

Purpose: This exercise shows how inheritance can model a taxonomy of related objects. Each media type shares a common identity (title, price) but carries unique attributes specific to its format, reflecting real-world library or inventory systems.

Given Input: Book("Clean Code", 499, "Robert C. Martin"), Magazine("Wired", 150, "Monthly"), DVD("Inception", 299, 148)

Expected Output:

Book: Clean Code by Robert C. Martin - Rs.499
Magazine: Wired (Monthly) - Rs.150
DVD: Inception, 148 mins - Rs.299

class Media:
    def __init__(self, title, price):
        self.title = title
        self.price = price

    def describe(self):
        return f"{self.title} - Rs.{self.price}"

class Book(Media):
    def __init__(self, title, price, author):
        super().__init__(title, price)
        self.author = author

    def describe(self):
        return f"Book: {self.title} by {self.author} - Rs.{self.price}"

class Magazine(Media):
    def __init__(self, title, price, frequency):
        super().__init__(title, price)
        self.frequency = frequency

    def describe(self):
        return f"Magazine: {self.title} ({self.frequency}) - Rs.{self.price}"

class DVD(Media):
    def __init__(self, title, price, duration):
        super().__init__(title, price)
        self.duration = duration

    def describe(self):
        return f"DVD: {self.title}, {self.duration} mins - Rs.{self.price}"

items = [
    Book("Clean Code", 499, "Robert C. Martin"),
    Magazine("Wired", 150, "Monthly"),
    DVD("Inception", 299, 148)
]

for item in items:
    print(item.describe())Code language: Python (python)

Exercise 20: Discounted Order Subclass with 10% Off

Problem Statement: Write a Python program that creates an Order class with a total amount, then creates a DiscountedOrder subclass that applies a 10% discount to the total.

Purpose: This exercise models a common e-commerce pattern and shows how a child class can extend a parent’s behaviour by modifying a calculated value, without changing the parent class at all.

Given Input: DiscountedOrder("ORD001", 1200)

Expected Output:

Order ID: ORD001
Original Total: 1200
Discounted Total: 1080.0

class Order:
    def __init__(self, order_id, total):
        self.order_id = order_id
        self.total = total

    def get_total(self):
        return self.total

class DiscountedOrder(Order):
    def __init__(self, order_id, total):
        super().__init__(order_id, total)

    def get_total(self):
        return self.total * 0.90

order = DiscountedOrder("ORD001", 1200)
print("Order ID:", order.order_id)
print("Original Total:", order.total)
print("Discounted Total:", order.get_total())Code language: Python (python)

Exercise 21: Vehicle Class Hierarchy with Bike, Truck & Bus

Problem Statement: Write a Python program that defines a Vehicle base class and creates Bike, Truck, and Bus subclasses, each defining a unique max_speed attribute and a describe() method.

Purpose: This exercise reinforces the concept of class hierarchies and shows how subclasses can specialise a shared blueprint with their own attribute values, reflecting how real-world transport systems are categorised.

Given Input: Objects of Bike, Truck, and Bus classes

Expected Output:

Bike max speed: 120 km/h
Truck max speed: 90 km/h
Bus max speed: 100 km/h

class Vehicle:
    def __init__(self, max_speed):
        self.max_speed = max_speed

    def describe(self):
        print(f"{type(self).__name__} max speed: {self.max_speed} km/h")

class Bike(Vehicle):
    def __init__(self):
        super().__init__(120)

class Truck(Vehicle):
    def __init__(self):
        super().__init__(90)

class Bus(Vehicle):
    def __init__(self):
        super().__init__(100)

vehicles = [Bike(), Truck(), Bus()]
for v in vehicles:
    v.describe()Code language: Python (python)

Exercise 22: Identify Object’s Class Using type()

Problem Statement: Write a Python program that creates objects from multiple classes and uses the built-in type() function to identify which class each object belongs to.

Purpose: This exercise teaches you how Python tracks the type of every object at runtime. Understanding type() is essential for debugging, dynamic dispatch, and writing flexible code that reacts differently based on the type of object it receives.

Given Input: Objects from Dog, Cat, and Vehicle classes

Expected Output:

d is of type: Dog
c is of type: Cat
v is of type: Vehicle

class Dog:
    pass

class Cat:
    pass

class Vehicle:
    pass

d = Dog()
c = Cat()
v = Vehicle()

objects = {"d": d, "c": c, "v": v}

for name, obj in objects.items():
    print(f"{name} is of type: {type(obj).__name__}")Code language: Python (python)

Exercise 23: Type Checking with isinstance() & issubclass()

Problem Statement: Write a Python program that uses isinstance() to check whether an object is an instance of a given class, and issubclass() to check whether one class is a subclass of another.

Purpose: This exercise teaches you two of Python’s most important type-inspection tools. Unlike type(), both functions are inheritance-aware, making them essential for writing flexible, safe code that handles mixed object types gracefully.

Given Input: A Dog class inheriting from Animal, and an instance d = Dog()

Expected Output:

Is d an instance of Dog? True
Is d an instance of Animal? True
Is Dog a subclass of Animal? True
Is Animal a subclass of Dog? False

class Animal:
    pass

class Dog(Animal):
    pass

d = Dog()

print("Is d an instance of Dog?", isinstance(d, Dog))
print("Is d an instance of Animal?", isinstance(d, Animal))
print("Is Dog a subclass of Animal?", issubclass(Dog, Animal))
print("Is Animal a subclass of Dog?", issubclass(Animal, Dog))Code language: Python (python)

Exercise 24: Vector Addition Using add Overloading

Problem Statement: Write a Python program that creates a Vector class representing a 2D vector, and implements the __add__ dunder method so that two Vector objects can be added using the + operator.

Purpose: This exercise introduces operator overloading, a powerful OOP feature that lets your custom classes behave like built-in types. Implementing __add__ makes your objects integrate naturally with Python’s syntax.

Given Input: v1 = Vector(2, 3) and v2 = Vector(4, 1)

Expected Output: Vector(6, 4)

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __add__(self, other):
        return Vector(self.x + other.x, self.y + other.y)

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

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

result = v1 + v2
print(result)Code language: Python (python)

Exercise 25: Cart Length Using len Overloading

Problem Statement: Write a Python program that creates a Cart class that stores a list of items, and implements __len__ so that calling len(cart) returns the number of items currently in the cart.

Purpose: This exercise introduces the __len__ dunder method, which lets your custom class integrate with Python’s built-in len() function. This is part of Python’s data model and makes your objects behave like native sequences or containers.

Given Input: A cart with items ["apple", "banana", "mango"]

Expected Output: Number of items in cart: 3

class Cart:
    def __init__(self):
        self.items = []

    def add_item(self, item):
        self.items.append(item)

    def __len__(self):
        return len(self.items)

cart = Cart()
cart.add_item("apple")
cart.add_item("banana")
cart.add_item("mango")

print("Number of items in cart:", len(cart))Code language: Python (python)

Exercise 26: Private Balance with Property Getter & Setter

Problem Statement: Write a Python program that creates a BankAccount class where the balance is stored as a private attribute __balance, and exposed safely through a @property getter and a setter that validates the value before updating it.

Purpose: This exercise demonstrates encapsulation, one of the four pillars of OOP. Using name-mangled private attributes alongside @property lets you control how external code reads and modifies internal state, preventing invalid data from being assigned.

Given Input: BankAccount(1000), then deposit 500, then attempt to set balance to -200

Expected Output:

Current balance: 1000
Current balance: 1500
Invalid balance. Must be non-negative.

class BankAccount:
    def __init__(self, initial_balance):
        self.__balance = initial_balance

    @property
    def balance(self):
        return self.__balance

    @balance.setter
    def balance(self, amount):
        if amount < 0:
            print("Invalid balance. Must be non-negative.")
        else:
            self.__balance = amount

    def deposit(self, amount):
        self.balance = self.__balance + amount

account = BankAccount(1000)
print("Current balance:", account.balance)

account.deposit(500)
print("Current balance:", account.balance)

account.balance = -200Code language: Python (python)

Exercise 27: Callable Object Class Using call

Problem Statement: Write a Python program that creates a Multiplier class which stores a factor, and implements __call__ so that an instance of the class can be invoked directly like a function to multiply a given number by that factor.

Purpose: This exercise introduces the __call__ dunder method, which makes any object callable. This pattern is commonly used in machine learning (layer objects), decorators, and anywhere you need a stateful function-like object.

Given Input: Multiplier(3) called with 10, and Multiplier(5) called with 7

Expected Output:

30
35

class Multiplier:
    def __init__(self, factor):
        self.factor = factor

    def __call__(self, value):
        return self.factor * value

triple = Multiplier(3)
penta = Multiplier(5)

print(triple(10))
print(penta(7))Code language: Python (python)

Exercise 28: Flight Class with Passenger Capacity Check

Problem Statement: Write a Python program that creates a Passenger class and a Flight class. The Flight class should manage a list of Passenger objects and block further bookings when the seat capacity is reached.

Purpose: This exercise models a real-world object composition scenario where one class owns and manages a collection of another class. It also teaches boundary enforcement, where business rules (capacity limits) are built directly into the class methods.

Given Input: A Flight with capacity 2, then three booking attempts

Expected Output:

Alice booked on Flight AI202.
Bob booked on Flight AI202.
Sorry, Flight AI202 is fully booked.

class Passenger:
    def __init__(self, name):
        self.name = name

class Flight:
    def __init__(self, flight_number, capacity):
        self.flight_number = flight_number
        self.capacity = capacity
        self.passengers = []

    def book(self, passenger):
        if len(self.passengers) < self.capacity:
            self.passengers.append(passenger)
            print(f"{passenger.name} booked on Flight {self.flight_number}.")
        else:
            print(f"Sorry, Flight {self.flight_number} is fully booked.")

flight = Flight("AI202", 2)
flight.book(Passenger("Alice"))
flight.book(Passenger("Bob"))
flight.book(Passenger("Charlie"))Code language: Python (python)

Exercise 29: Zoo Class that Feeds All Animals

Problem Statement: Write a Python program that defines an Animal base class with an eat() method, creates a few subclasses with their own eat() implementations, and builds a Zoo class that holds a list of animals and calls eat() on all of them via a feed_all() method.

Purpose: This exercise combines composition with polymorphism. The Zoo class does not need to know the specific type of each animal; it simply calls the shared eat() interface on every object in its collection, and each animal responds in its own way.

Given Input: A zoo containing a Lion, a Elephant, and a Parrot

Expected Output:

Lion eats meat.
Elephant eats grass.
Parrot eats seeds.

class Animal:
    def eat(self):
        return "eating."

class Lion(Animal):
    def eat(self):
        return "Lion eats meat."

class Elephant(Animal):
    def eat(self):
        return "Elephant eats grass."

class Parrot(Animal):
    def eat(self):
        return "Parrot eats seeds."

class Zoo:
    def __init__(self):
        self.animals = []

    def add_animal(self, animal):
        self.animals.append(animal)

    def feed_all(self):
        for animal in self.animals:
            print(animal.eat())

zoo = Zoo()
zoo.add_animal(Lion())
zoo.add_animal(Elephant())
zoo.add_animal(Parrot())

zoo.feed_all()Code language: Python (python)

Exercise 30: Character Class with Auto Level-Up Logic

Problem Statement: Write a Python program that creates a Character class with health, exp, and level attributes. The character should automatically level up and reset exp whenever accumulated experience reaches or exceeds 100.

Purpose: This exercise shows how to embed game logic directly into a class using a method that manages state transitions. It also demonstrates how to handle overflow (excess exp after levelling up) and keep multiple related attributes in sync.

Given Input: Character("Aria", health=100), then gain_exp(60) twice

Expected Output:

Aria gained 60 exp. (Total: 60)
Aria gained 60 exp. Level up! Now Level 2. (Remaining exp: 20)

class Character:
    def __init__(self, name, health):
        self.name = name
        self.health = health
        self.exp = 0
        self.level = 1

    def gain_exp(self, amount):
        self.exp += amount
        if self.exp >= 100:
            self.exp -= 100
            self.level += 1
            print(f"{self.name} gained {amount} exp. Level up! Now Level {self.level}. (Remaining exp: {self.exp})")
        else:
            print(f"{self.name} gained {amount} exp. (Total: {self.exp})")

hero = Character("Aria", health=100)
hero.gain_exp(60)
hero.gain_exp(60)Code language: Python (python)

Exercise 31: Playlist Class with Add, Remove & Shuffle

Problem Statement: Write a Python program that defines a Song class and a Playlist class. The Playlist should support adding songs, removing songs by title, and shuffling the order of the playlist randomly.

Purpose: This exercise reinforces object composition, list manipulation, and the use of the standard library. Managing a collection of objects with add, remove, and reorder operations is a pattern found in media players, task managers, and many real-world applications.

Given Input: A playlist with three songs, then a removal and a shuffle

Expected Output:

Playlist: Blinding Lights, Levitating, Peaches
Removed: Levitating
After shuffle: (order will vary)

import random

class Song:
    def __init__(self, title, artist):
        self.title = title
        self.artist = artist

class Playlist:
    def __init__(self, name):
        self.name = name
        self.songs = []

    def add_song(self, song):
        self.songs.append(song)

    def remove_song(self, title):
        original_count = len(self.songs)
        self.songs = [s for s in self.songs if s.title != title]
        if len(self.songs) < original_count:
            print(f"Removed: {title}")
        else:
            print(f"Song '{title}' not found in playlist.")

    def shuffle(self):
        random.shuffle(self.songs)

    def display(self):
        titles = [s.title for s in self.songs]
        print(f"Playlist: {', '.join(titles)}")

playlist = Playlist("My Mix")
playlist.add_song(Song("Blinding Lights", "The Weeknd"))
playlist.add_song(Song("Levitating", "Dua Lipa"))
playlist.add_song(Song("Peaches", "Justin Bieber"))

playlist.display()
playlist.remove_song("Levitating")
playlist.shuffle()
print("After shuffle:", end=" ")
playlist.display()Code language: Python (python)