Chapter 7 Exercises

Comprehensive exercises covering object-oriented programming in Python, sorted from easiest to hardest.

Exercises

Exercise 1: Basic Class and Object

Create a class called Student with instance variables name and student_id. Create a constructor that initializes these values. Read name and student_id from input, create a Student object, and print both attributes.

Answer:

1
class Student:
2
    def __init__(self, name, student_id):
3
        self.name = name
4
        self.student_id = student_id
5

6
name = input()
7
student_id = input()
8
student = Student(name, student_id)
9
print(f"Name: {student.name}, Student ID: {student.student_id}")

Exercise 2: Instance Methods

Create a class called Rectangle with instance variables length and width. Add methods area() and perimeter() that return the area and perimeter respectively. Read length and width from input, create a Rectangle, and display both values.

Answer:

1
class Rectangle:
2
    def __init__(self, length, width):
3
        self.length = length
4
        self.width = width
5

6
    def area(self):
7
        return self.length * self.width
8

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

12
length = float(input())
13
width = float(input())
14
rect = Rectangle(length, width)
15
print(f"Area: {rect.area()}")
16
print(f"Perimeter: {rect.perimeter()}")

Exercise 3: Class Variables and Methods

Create a class called Counter with a class variable count = 0. In the constructor, increment this counter. Add a class method get_count() that returns the total count. Create 3 Counter objects and print the total count.

Answer:

1
class Counter:
2
    count = 0
3

4
    def __init__(self):
5
        Counter.count += 1
6

7
    @classmethod
8
    def get_count(cls):
9
        return cls.count
10

11
c1 = Counter()
12
c2 = Counter()
13
c3 = Counter()
14

15
print(f"Total count: {Counter.get_count()}")

Exercise 4: Public and Private Attributes

Create a class called BankAccount with a public attribute account_holder and a private attribute __balance. Add a public method get_balance() that returns the balance. Initialize balance to 0 in the constructor. Read account holder name, create an account, and display the balance.

Answer:

1
class BankAccount:
2
    def __init__(self, account_holder):
3
        self.account_holder = account_holder
4
        self.__balance = 0
5

6
    def get_balance(self):
7
        return self.__balance
8

9
name = input()
10
account = BankAccount(name)
11
print(f"Account Holder: {account.account_holder}")
12
print(f"Balance: {account.get_balance()}")

Exercise 5: Properties

Create a class called Temperature with a private attribute _celsius. Use properties to get and set celsius, ensuring it cannot be set below -273.15. Read initial temperature, then a new temperature, and display both.

Answer:

1
class Temperature:
2
    def __init__(self, celsius):
3
        self._celsius = celsius
4

5
    @property
6
    def celsius(self):
7
        return self._celsius
8

9
    @celsius.setter
10
    def celsius(self, value):
11
        if value >= -273.15:
12
            self._celsius = value
13

14
initial = float(input())
15
new_temp = float(input())
16

17
temp = Temperature(initial)
18
print(f"Initial: {temp.celsius}°C")
19
temp.celsius = new_temp
20
print(f"New: {temp.celsius}°C")

Exercise 6: Special Methods - str and repr

Create a class called Point with x and y coordinates. Implement __str__ to return “Point(x, y)” and __repr__ to return “Point(x, y)”. Read x and y, create a Point, and print it using both str and repr.

Answer:

1
class Point:
2
    def __init__(self, x, y):
3
        self.x = x
4
        self.y = y
5

6
    def __str__(self):
7
        return f"Point({self.x}, {self.y})"
8

9
    def __repr__(self):
10
        return f"Point({self.x}, {self.y})"
11

12
x = int(input())
13
y = int(input())
14
point = Point(x, y)
15
print(str(point))
16
print(repr(point))

Exercise 7: Special Methods - eq

Create a class called Fraction with numerator and denominator. Implement __eq__ to compare two fractions (a/b == c/d if ad == bc). Read two fractions and check if they are equal.

Answer:

1
class Fraction:
2
    def __init__(self, numerator, denominator):
3
        self.numerator = numerator
4
        self.denominator = denominator
5

6
    def __eq__(self, other):
7
        if isinstance(other, Fraction):
8
            return (self.numerator * other.denominator ==
9
                    self.denominator * other.numerator)
10
        return False
11

12
num1 = int(input())
13
den1 = int(input())
14
num2 = int(input())
15
den2 = int(input())
16

17
f1 = Fraction(num1, den1)
18
f2 = Fraction(num2, den2)
19
print(f1 == f2)

Exercise 8: Basic Inheritance

Create a parent class Vehicle with brand and model attributes, and a start() method that returns “Vehicle started”. Create a child class Car that inherits from Vehicle and adds a honk() method. Read brand and model, create a Car, and call both methods.

Answer:

1
class Vehicle:
2
    def __init__(self, brand, model):
3
        self.brand = brand
4
        self.model = model
5

6
    def start(self):
7
        return "Vehicle started"
8

9
class Car(Vehicle):
10
    def honk(self):
11
        return "Beep beep!"
12

13
brand = input()
14
model = input()
15
car = Car(brand, model)
16
print(car.start())
17
print(car.honk())

Exercise 9: Method Overriding

Create a parent class Shape with an area() method that returns 0. Create child classes Rectangle and Circle that override area() to calculate their respective areas. Read values and create objects, then print their areas.

Answer:

1
import math
2

3
class Shape:
4
    def area(self):
5
        return 0
6

7
class Rectangle(Shape):
8
    def __init__(self, length, width):
9
        self.length = length
10
        self.width = width
11

12
    def area(self):
13
        return self.length * self.width
14

15
class Circle(Shape):
16
    def __init__(self, radius):
17
        self.radius = radius
18

19
    def area(self):
20
        return math.pi * self.radius ** 2
21

22
length = float(input())
23
width = float(input())
24
radius = float(input())
25

26
rect = Rectangle(length, width)
27
circle = Circle(radius)
28

29
print(f"Rectangle area: {rect.area()}")
30
print(f"Circle area: {circle.area():.2f}")

Exercise 10: Using super()

Create a parent class Person with name and age, and a display() method. Create a child class Student that adds student_id and overrides display() to include student_id using super(). Read values and create a Student, then display.

Answer:

1
class Person:
2
    def __init__(self, name, age):
3
        self.name = name
4
        self.age = age
5

6
    def display(self):
7
        return f"Name: {self.name}, Age: {self.age}"
8

9
class Student(Person):
10
    def __init__(self, name, age, student_id):
11
        super().__init__(name, age)
12
        self.student_id = student_id
13

14
    def display(self):
15
        return f"{super().display()}, Student ID: {self.student_id}"
16

17
name = input()
18
age = int(input())
19
student_id = input()
20

21
student = Student(name, age, student_id)
22
print(student.display())

Exercise 11: Multiple Inheritance

Create two parent classes: Flyable with a fly() method returning “Flying!” and Swimmable with a swim() method returning “Swimming!”. Create a child class Duck that inherits from both and has a name attribute. Read name and call all three methods.

Answer:

1
class Flyable:
2
    def fly(self):
3
        return "Flying!"
4

5
class Swimmable:
6
    def swim(self):
7
        return "Swimming!"
8

9
class Duck(Flyable, Swimmable):
10
    def __init__(self, name):
11
        self.name = name
12

13
    def quack(self):
14
        return f"{self.name} quacks!"
15

16
name = input()
17
duck = Duck(name)
18
print(duck.fly())
19
print(duck.swim())
20
print(duck.quack())

Exercise 12: Polymorphism with Duck Typing

Create three classes Dog, Cat, and Bird, each with a speak() method. Create a function make_animal_speak() that takes any object with a speak() method and calls it. Test with all three classes.

Answer:

1
class Dog:
2
    def speak(self):
3
        return "Woof!"
4

5
class Cat:
6
    def speak(self):
7
        return "Meow!"
8

9
class Bird:
10
    def speak(self):
11
        return "Chirp!"
12

13
def make_animal_speak(animal):
14
    return animal.speak()
15

16
dog = Dog()
17
cat = Cat()
18
bird = Bird()
19

20
print(make_animal_speak(dog))
21
print(make_animal_speak(cat))
22
print(make_animal_speak(bird))

Exercise 13: Abstract Base Class

Create an abstract base class Shape with abstract methods area() and perimeter(). Create concrete classes Rectangle and Circle that implement these methods. Read values and display areas and perimeters.

Answer:

1
from abc import ABC, abstractmethod
2
import math
3

4
class Shape(ABC):
5
    @abstractmethod
6
    def area(self):
7
        pass
8

9
    @abstractmethod
10
    def perimeter(self):
11
        pass
12

13
class Rectangle(Shape):
14
    def __init__(self, length, width):
15
        self.length = length
16
        self.width = width
17

18
    def area(self):
19
        return self.length * self.width
20

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

24
class Circle(Shape):
25
    def __init__(self, radius):
26
        self.radius = radius
27

28
    def area(self):
29
        return math.pi * self.radius ** 2
30

31
    def perimeter(self):
32
        return 2 * math.pi * self.radius
33

34
length = float(input())
35
width = float(input())
36
radius = float(input())
37

38
rect = Rectangle(length, width)
39
circle = Circle(radius)
40

41
print(f"Rectangle - Area: {rect.area()}, Perimeter: {rect.perimeter()}")
42
print(f"Circle - Area: {circle.area():.2f}, Perimeter: {circle.perimeter():.2f}")

Exercise 14: Composition

Create an Engine class with a start() method returning “Engine started”. Create a Car class that has an Engine (composition). Create a Car and start its engine, then print “Car is ready!”.

Answer:

1
class Engine:
2
    def start(self):
3
        return "Engine started"
4

5
class Car:
6
    def __init__(self):
7
        self.engine = Engine()
8

9
    def start_car(self):
10
        return self.engine.start()
11

12
car = Car()
13
print(car.start_car())
14
print("Car is ready!")

Exercise 15: Complete Bank Account System

Create a BankAccount class with private __balance, public account_holder, class variable account_count, and methods: deposit(amount), withdraw(amount), get_balance(). Use a class method to get account count. Read account holder name and initial balance, deposit 100, withdraw 50, then display balance and account count.

Answer:

1
class BankAccount:
2
    account_count = 0
3

4
    def __init__(self, account_holder, initial_balance=0):
5
        self.account_holder = account_holder
6
        self.__balance = initial_balance
7
        BankAccount.account_count += 1
8

9
    def deposit(self, amount):
10
        if amount > 0:
11
            self.__balance += amount
12

13
    def withdraw(self, amount):
14
        if 0 < amount <= self.__balance:
15
            self.__balance -= amount
16

17
    def get_balance(self):
18
        return self.__balance
19

20
    @classmethod
21
    def get_account_count(cls):
22
        return cls.account_count
23

24
name = input()
25
initial = float(input())
26

27
account = BankAccount(name, initial)
28
account.deposit(100)
29
account.withdraw(50)
30

31
print(f"Balance: {account.get_balance()}")
32
print(f"Total accounts: {BankAccount.get_account_count()}")

Exercise 16: Operator Overloading

Create a Vector class with x and y coordinates. Implement __add__ to add two vectors and __str__ to display as “Vector(x, y)”. Read two vectors, add them, and print the result.

Answer:

1
class Vector:
2
    def __init__(self, x, y):
3
        self.x = x
4
        self.y = y
5

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

9
    def __str__(self):
10
        return f"Vector({self.x}, {self.y})"
11

12
x1 = int(input())
13
y1 = int(input())
14
x2 = int(input())
15
y2 = int(input())
16

17
v1 = Vector(x1, y1)
18
v2 = Vector(x2, y2)
19
v3 = v1 + v2
20

21
print(v3)

Exercise 17: Data Class

Create a data class Student with fields name, age, and grade. Create two Student objects with the same values and one with different values. Test equality comparison and print the results.

Answer:

1
from dataclasses import dataclass
2

3
@dataclass
4
class Student:
5
    name: str
6
    age: int
7
    grade: int
8

9
name1 = input()
10
age1 = int(input())
11
grade1 = int(input())
12
name2 = input()
13
age2 = int(input())
14
grade2 = int(input())
15

16
student1 = Student(name1, age1, grade1)
17
student2 = Student(name1, age1, grade1)
18
student3 = Student(name2, age2, grade2)
19

20
print(student1 == student2)
21
print(student1 == student3)

Exercise 18: Complex Inheritance Hierarchy

Create a base class Animal with name and make_sound() method. Create Mammal that inherits from Animal and adds fur_color. Create Dog that inherits from Mammal and overrides make_sound() to return “Woof!”. Read name and fur_color, create a Dog, and display all information.

Answer:

1
class Animal:
2
    def __init__(self, name):
3
        self.name = name
4

5
    def make_sound(self):
6
        return "Some sound"
7

8
class Mammal(Animal):
9
    def __init__(self, name, fur_color):
10
        super().__init__(name)
11
        self.fur_color = fur_color
12

13
class Dog(Mammal):
14
    def make_sound(self):
15
        return "Woof!"
16

17
name = input()
18
fur_color = input()
19

20
dog = Dog(name, fur_color)
21
print(f"Name: {dog.name}")
22
print(f"Fur Color: {dog.fur_color}")
23
print(f"Sound: {dog.make_sound()}")

Exercise 19: Special Methods - Comparison

Create a Student class with name and grade. Implement __lt__ to compare students by grade. Read two students, compare them, and print which student has a higher grade.

Answer:

1
class Student:
2
    def __init__(self, name, grade):
3
        self.name = name
4
        self.grade = grade
5

6
    def __lt__(self, other):
7
        return self.grade < other.grade
8

9
name1 = input()
10
grade1 = int(input())
11
name2 = input()
12
grade2 = int(input())
13

14
student1 = Student(name1, grade1)
15
student2 = Student(name2, grade2)
16

17
if student1 < student2:
18
    print(f"{student2.name} has a higher grade")
19
else:
20
    print(f"{student1.name} has a higher grade")

Exercise 20: Complete OOP System

Create a library system: Abstract base class Item with abstract get_info(), concrete classes Book and Magazine that inherit from Item, and a Library class that uses composition to store items. Add methods to add items and display all items. Read book and magazine info, add them to library, and display all.

Answer:

1
from abc import ABC, abstractmethod
2

3
class Item(ABC):
4
    def __init__(self, title, author):
5
        self.title = title
6
        self.author = author
7

8
    @abstractmethod
9
    def get_info(self):
10
        pass
11

12
class Book(Item):
13
    def get_info(self):
14
        return f"Book: {self.title} by {self.author}"
15

16
class Magazine(Item):
17
    def get_info(self):
18
        return f"Magazine: {self.title} by {self.author}"
19

20
class Library:
21
    def __init__(self):
22
        self.items = []
23

24
    def add_item(self, item):
25
        self.items.append(item)
26

27
    def display_all(self):
28
        for item in self.items:
29
            print(item.get_info())
30

31
book_title = input()
32
book_author = input()
33
mag_title = input()
34
mag_author = input()
35

36
library = Library()
37
library.add_item(Book(book_title, book_author))
38
library.add_item(Magazine(mag_title, mag_author))
39
library.display_all()

Table of Contents

Table of Contents

Course Progress

Chapter 7 Exercises

Exercises

Exercise 1: Basic Class and Object

Exercise 2: Instance Methods

Exercise 3: Class Variables and Methods

Exercise 4: Public and Private Attributes

Exercise 5: Properties

Exercise 6: Special Methods - __str__ and __repr__

Exercise 7: Special Methods - __eq__

Exercise 8: Basic Inheritance

Exercise 9: Method Overriding

Exercise 10: Using super()

Exercise 11: Multiple Inheritance

Exercise 12: Polymorphism with Duck Typing

Exercise 13: Abstract Base Class

Exercise 14: Composition

Exercise 15: Complete Bank Account System

Exercise 16: Operator Overloading

Exercise 17: Data Class

Exercise 18: Complex Inheritance Hierarchy

Exercise 19: Special Methods - Comparison

Exercise 20: Complete OOP System

Course Progress

Exercise 6: Special Methods - str and repr

Exercise 7: Special Methods - eq