OOP Classes

You already organise the world into things. A phone is a thing: it has data (a model, a battery level) and it does jobs (ring, take a photo). A student is a thing too: they have a name and a grade, and they do things like move up a year. Object-Oriented Programming (OOP) lets you write programs the same way — by building “things” called objects that bundle their data and their actions together in one place.

Before OOP, you stored a student's data in separate variables and wrote loose functions that hoped to be passed the right ones. OOP fixes that by keeping each object's data and the actions that work on it locked together. This makes programs easier to read, reuse and maintain — and it is exactly what Paper 4 asks you to design and write.

By the end of this page you will be able to explain the difference between a class and an object, write a class with a constructor and attributes, add methods that change an object's data, and create objects and use them in a main program — the four skills every Paper 4 OOP question is built from.

Think about a printed registration form. The blank form is the plan — it has spaces for a name and a grade, but it holds no real student. When you photocopy it and write “Musarrat, Grade 11” on one copy and “Aymaan, Grade 12” on another, each filled-in copy is a real thing with its own values.

In OOP, the blank form is the class. Each filled-in copy is an object (also called an instance). You define the class once, then you can create as many objects from it as you like, and each object keeps its own separate data.

A class definition starts with the keyword class followed by the class name (use PascalCase: Student, BankAccount). Everything that belongs to the class is indented underneath it.

Inside the class, the constructor in Python is always named __init__ (two underscores either side). Its first parameter is always self — that word stands for “the object being built right now”. The remaining parameters are the values you hand over when creating the object. Inside the constructor you copy each parameter into an attribute written as self.attributeName.

class Student:
    def __init__(self, name, grade):
        self.name  = name      # attribute: stores the student's name
        self.grade = grade     # attribute: stores the year group

Here is the same idea in Cambridge pseudocode. The pseudocode constructor is a procedure named NEW, and attributes are declared explicitly:

CLASS Student
    PUBLIC Name : STRING
    PUBLIC Grade : INTEGER
    PUBLIC PROCEDURE NEW(GivenName : STRING, GivenGrade : INTEGER)
        Name  <- GivenName
        Grade <- GivenGrade
    ENDPROCEDURE
ENDCLASS

A method is just a function written inside the class. Like the constructor, its first parameter is self, because the method needs to know which object's attributes it should work on. To reach an attribute from inside a method, you write self.attributeName.

Here is a method that promotes a student by adding 1 to their grade. Notice it reads the current grade with self.grade, adds one, and stores the new value back into the same attribute:

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

    def promote(self):
        self.grade = self.grade + 1   # change this object's grade

    def display(self):
        print("Name:",  self.name)
        print("Grade:", self.grade)

The pseudocode equivalent uses PUBLIC PROCEDURE for an action that does something, and PUBLIC FUNCTION ... RETURNS for a method that hands a value back:

PUBLIC PROCEDURE Promote()
    Grade <- Grade + 1
ENDPROCEDURE

PUBLIC FUNCTION GetGrade() RETURNS INTEGER
    RETURN Grade
ENDFUNCTION

To create an object, write the class name followed by brackets, passing in the values the constructor expects. The constructor runs automatically. This act is called instantiation, and the object you get back is an instance of the class. Once you have the object you reach its attributes with object.attribute and call its methods with object.method().

musarrat = Student("Musarrat", 11)   # create (instantiate) an object
musarrat.display()                   # call a method
musarrat.promote()                   # change the object's data
musarrat.display()                   # show the updated data

# Output:
# Name: Musarrat
# Grade: 11
# Name: Musarrat
# Grade: 12

The pseudocode equivalent creates the object with NEW and calls methods with the same dot notation:

Musarrat <- NEW Student("Musarrat", 11)
Musarrat.Display()
Musarrat.Promote()
Musarrat.Display()

Each drill shows one class solved on the left, then a matching task of the same type on the right. Work through the left, cover it, then attempt the right before tapping Show answer. These are skill drills — no marks attached.

def promote(self):
    grade = grade + 1   # the grade never updates — why?

Fifteen exam-style tasks. Click Hint for bullet-point guidance, then Help to reveal a worked Python solution.