Topics from the IB Computer Science syllabus.

Modelling Real-World Entities in Python (OOP)

In this practical section, we will begin learning how to write object-oriented programs in Python. We will use a consistent scenario throughout the OOP unit: a game character system. This will help you build understanding step-by-step as concepts become more advanced.

STEP 1 | CREATING YOUR FIRST CLASS
We begin by modelling a simple game character.
A character has:

a name
a health value

This can be represented using a class.

This defines a class called Character.

__init__ is the constructor (runs when an object is created)
self.name and self.health are attribute

STEP 2 | CREATING OBJECTS (INSTANCES)
Now we create actual characters from the class:

In the above example each object:

Uses the same class
Stores different data

STEP 3 | ADDING BEHAVIOUR (METHODS)
Objects are not just data — they can perform actions.

Adding a method:

And to call the method.

CHALLENGE 1 | ADD A NEW METHOD

Add a new method called display_info() that prints:

Name: Aria, Health: 100

Test it on both hero and enemy.

Need more help? (Sample Answer)

Add a method to the class that prints the character’s details:

class Character:
    def __init__(self, name, health):
        self.name = name
        self.health = health

    # New method to display character information
    def display_info(self):
        print("Name:", self.name, ", Health:", self.health)


# Create objects
hero = Character("Aria", 100)
enemy = Character("Goblin", 50)

# Test the method on both objects
hero.display_info()
enemy.display_info()

STEP 4 | EINTRODUCING ENCAPULATION
Encapsulation means protecting data inside the object.

We will make health harder to modify directly:

CHALLENGE 2 | PROTECT DATA

Modify the take_damage() method so that:

Health cannot go below 0

Need more help? (Sample Answer)

Update the method to ensure health never becomes negative:

class Character:
    def __init__(self, name, health):
        self.name = name
        self.__health = health

    def take_damage(self, amount):
        self.__health -= amount

        # Ensure health does not go below 0
        if self.__health < 0:
            self.__health = 0

This checks if health has dropped below 0 and resets it to 0 if needed.

STEP 5 | INHERITANCE

We now create a more specific type of character.

The Warrior class:

Inherits from Character
Reuses existing method

CHALLENGE 3 | INHERITANCE

Create a new class called Mage that:

Inherits from Character
Has a method cast_spell() that prints a message

Need more help? (Sample Answer)

Create a new class that inherits from Character and add a new method:

class Mage(Character):

    # New method specific to Mage
    def cast_spell(self):
        print(self.name + " casts a powerful spell!")


# Example usage
mage = Mage("Luna", 80)
mage.cast_spell()

The Mage class inherits all attributes and methods from Character, and adds its own unique behaviour.

STEP 6 | POLYMORPHISM
Different objects can respond to the same method differently.

Each object behaves differently even though the same method is called.

CHALLENGE 4 | POLYMORPHISM

Add a new class Archer that:

Overrides attack()
Prints a unique attack message

Need more help? (Sample Answer)

Create a new class that inherits from Character and overrides the attack method:

class Archer(Character):

    # Override the attack() method
    def attack(self):
        print(self.name + " shoots an arrow!")


# Example usage
archer = Archer("Robin", 90)
archer.attack()

The Archer class reuses the structure of Character but changes how the attack() method behaves.

CHALLENGE 4 | MINI TAKS

Create a small system with:

At least 2 different character types

Each must:

Have a constructor
Have at least 2 methods
Override one method (polymorphism)

Then:

Store them in a list
Loop through them and call their methods

Need more help? (Sample Answer)

This is one possible solution that meets all the requirements:

# Base class
class Character:
    def __init__(self, name, health):
        self.name = name
        self.health = health

    def attack(self):
        print(self.name + " attacks!")

    def display_info(self):
        print("Name:", self.name, ", Health:", self.health)


# First subclass
class Warrior(Character):

    # Override attack method (polymorphism)
    def attack(self):
        print(self.name + " swings a sword!")

    def defend(self):
        print(self.name + " raises a shield!")


# Second subclass
class Mage(Character):

    # Override attack method (polymorphism)
    def attack(self):
        print(self.name + " casts a fireball!")

    def cast_spell(self):
        print(self.name + " casts a powerful spell!")


# Create objects
w = Warrior("Thor", 120)
m = Mage("Luna", 80)

# Store objects in a list
characters = [w, m]

# Loop through and call methods
for c in characters:
    c.display_info()
    c.attack()

This example demonstrates:

Classes and objects
Multiple subclasses (inheritance)
Method overriding (polymorphism)
Multiple methods per class
Using a list to manage objects

COMPUTATIONAL THINKING | OBJECT ORIENTED PROGRAMMING

SECTION 1 | B3.1.1 FUNDAMENTALS OF OBJECT ORIENTED PROGRAMMING (OOP)

SECTION 2 | ADVANTAGES AND DISADVANTAGES

CHALLENGE 1 | ADD A NEW METHOD

CHALLENGE 2 | PROTECT DATA

CHALLENGE 3 | INHERITANCE

CHALLENGE 4 | POLYMORPHISM

CHALLENGE 4 | MINI TAKS

B3.1.1 Check Your Understanding

1. What is a class in OOP?

2. What does encapsulation help to achieve?

3. What is inheritance?

4. What is polymorphism?

5. When is OOP most appropriate?