B3 Object-oriented programming (classes, inheritance, polymorphism) (HL-heavy) – IB Computer Science exam questions with mark scheme

1Core5 marks

Write a Python class Student with attributes name (a string) and marks (a list of integers), set when an object is created, and a method average() that returns the mean of the marks.

[5]

Class header class Student:(1)
Constructor __init__ with self and parameters for name and marks(1)
Assigns both attributes using self.name and self.marks(1)
Method average defined inside the class with self as its parameter(1)
Returns sum(self.marks) / len(self.marks) (or equivalent loop)(1)

Examiner tip: Attributes need the self. prefix; without it the values are lost when __init__ ends.

2StandardHL only5 marks

Consider the program below.

class Vehicle:
    def __init__(self, reg, wheels=4):
        self.reg = reg
        self.wheels = wheels

    def describe(self):
        return self.reg + " has " + str(self.wheels) + " wheels"

class Motorbike(Vehicle):
    def __init__(self, reg):
        super().__init__(reg, 2)
        self.sidecar = False

    def describe(self):
        return super().describe() + " and no sidecar"

v = Vehicle("AB12")
m = Motorbike("XY99")
print(v.describe())
print(m.describe())
print(isinstance(m, Vehicle))

(a) State the output of the program. [3]

(b) Identify the method, other than the constructor __init__, that is overridden in Motorbike. [1]

(a) AB12 has 4 wheels(1)
XY99 has 2 wheels and no sidecar(1)
True(1)
(b) describe(1)
(c) Calls the superclass constructor so the inherited attributes (reg and wheels) are initialised, here with wheels set to 2(1)
Answer: (a) AB12 has 4 wheels / XY99 has 2 wheels and no sidecar / True (b) describe (c) runs Vehicle's constructor
Examiner tip: Boolean outputs are written as True with a capital T.

3StandardHL only4 marks

Consider the program below.

import math

class Shape:
    def area(self):
        return 0

class Circle(Shape):
    def __init__(self, r):
        self.r = r
    def area(self):
        return math.pi * self.r ** 2

class Rectangle(Shape):
    def __init__(self, w, h):
        self.w = w
        self.h = h
    def area(self):
        return self.w * self.h

for s in [Circle(3), Rectangle(4, 5)]:
    print(type(s).__name__ + ": " + format(s.area(), ".2f"))

(a) State the output. [2]

(b) Define the term polymorphism. [1]

(a) Circle: 28.27(1)
Rectangle: 20.00(1)
(b) The ability of different classes to provide their own version of the same method, so objects can be treated through a common interface/name (accept 'one interface, many forms' / 'the same method call behaves differently depending on the object's class'; reject 'many forms' alone)(1)
(c) The same call s.area() runs the Circle version for one object and the Rectangle version for the other, chosen at run time according to the object's class (accept: each subclass overrides area from Shape, so the one call in the loop gives different behaviour; do not award 'the classes override area' with no link to the call in the loop)(1)
Answer: (a) Circle: 28.27 / Rectangle: 20.00 (b) same method name, different behaviour per class (c) one call s.area() runs a different overridden version for each object
Examiner tip: In (c) say that one call produces different behaviour depending on the object type.

4Hard6 marks

A bank wants to encapsulate its account data. Write a Python class BankAccount that:

stores the balance as a private attribute set from an opening balance;
has a method get_balance();
has a method deposit(amount) that only accepts positive amounts;
has a method withdraw(amount) that does not allow the balance to go below zero.

Each method that changes the balance should return True if it succeeded and False otherwise.

[6]

Balance stored as a private attribute (name begins with double underscore, e.g. self.__balance; allow a single leading underscore if the class clearly treats it as non-public)(1)
Constructor takes the opening balance and assigns it(1)
get_balance returns the private attribute(1)
deposit checks amount > 0 before adding to the balance(1)
withdraw checks that the amount does not exceed the balance (balance would not go below zero) before subtracting (a check that the amount is positive is allowed but not required)(1)
Returns True on success and False on failure in both methods(1)

Answer:

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

    def get_balance(self):
        return self.__balance

    def deposit(self, amount):
        if amount > 0:
            self.__balance += amount
            return True
        return False

    def withdraw(self, amount):
        if 0 < amount <= self.__balance:
            self.__balance -= amount
            return True
        return False

Examiner tip: The attribute must be hidden (private) and changed only through validated methods; a public balance earns no encapsulation mark.

5Standard4 marks

A program models pets using a class Dog. The object rex = Dog("Rex", 3) is created, where "Rex" is the name and 3 is the age.

(a) Distinguish between a class and an object, using the Dog example. [2]

(b) State two benefits of using an object-oriented approach (classes and objects) when designing a large program. [2]

(a) A class is a template/blueprint that defines the attributes and methods (e.g. Dog defines name and age and behaviours)(1)
An object is a specific instance of a class with its own attribute values (e.g. rex with name 'Rex' and age 3)(1)
(b) Any one benefit from: reusability (a class is written once and used to create many objects or reused in other programs; allow code reuse through inheritance); modularity/easier maintenance (each class can be written, tested and changed separately); team working (different programmers can work on different classes); encapsulation protects an object's data from accidental change; classes model real-world entities, making the design easier to understand(1)
A second, different benefit from the list above (do not award the same idea twice, e.g. 'reuse' and 'less code to write')(1)
Answer: (a) class = blueprint defining attributes and methods; object (rex) = an instance with its own values (b) e.g. classes can be reused; modular code is easier to maintain / share across a team
Examiner tip: Use the Dog example (Dog vs rex) in (a); in (b) name two genuinely different benefits, as vague answers such as 'it is easier' or two versions of 'reuse' score only once or not at all.

6HardHL only6 marks

A library system uses the class diagram shown. Item is implemented as:

class Item:
    def __init__(self, title, item_id):
        self.title = title
        self.item_id = item_id

    def late_fee(self, days_late):
        return 0.10 * days_late

Book and DVD are subclasses of Item. A DVD costs £0.50 per day late; an ordinary Item costs £0.10 per day late.

(a) State the superclass and identify one attribute that a DVD object inherits. [2]

(b) Write the class DVD, including its constructor and a version of late_fee that charges £0.50 per day. [4]

(a) Superclass is Item(1)
An inherited attribute: title or item_id(1)
(b) class DVD(Item): – inherits from Item(1)
Constructor with title, item_id and duration that calls super().__init__(title, item_id) (allow Item.__init__(self, title, item_id))(1)
Sets self.duration = duration(1)
late_fee(self, days_late) overrides the superclass method and returns 0.50 * days_late (accept 0.5)(1)

Answer: (a) Item; title or item_id. (b)

class DVD(Item):
    def __init__(self, title, item_id, duration):
        super().__init__(title, item_id)
        self.duration = duration

    def late_fee(self, days_late):
        return 0.50 * days_late

Examiner tip: Call super().__init__ for inherited attributes instead of re-assigning them; override with the same method name and parameters.

Still losing marks on this topic?

Book a free introductory session and we'll find exactly which step is costing you.

Book a free intro