Classes, objects and constructors

OCR H446 references: 1.2.4(e), 2.2.1(f) and Appendix 5d

Many programs model real or imagined things: characters in a game, tracks in a music library, sensors in a laboratory or films in a streaming catalogue. Object-oriented programming gives us a structured way to describe what each kind of thing stores and what it can do.

In this worksheet, OCR pseudocode is shown so that you can read examination questions confidently. Every executable example and programming task uses clear Python.

You should already know how variables and functions work in Python.

By the end, you should be able to:

• distinguish a class from an object
• identify attributes, methods and constructors
• read a simple OCR pseudocode class
• define, instantiate and use a class in Python

From a general design to individual objects

Imagine a streaming service that needs to store thousands of films. Every film has the same kinds of information, such as a title and age rating, but each film has its own values.

A class describes that common design. It defines:

• the attributes each object will store
• the methods each object will be able to use

An object, also called an instance, is one particular item created from the class. Hidden Figures and Dune could be two different objects made from the same Film class.

Attributes and methods

An attribute stores data belonging to one object. A Film object might store title and age_rating.

A method is a procedure or function belonging to the class. It describes behaviour involving that object's data. A label() method could combine a film's title and rating into display text.

The constructor

A constructor runs when a new object is created. Its job is to place the new object into a sensible starting state by assigning its initial attribute values.

OCR pseudocode

class Film
    title
    ageRating

    public procedure new(givenTitle, givenRating)
        title = givenTitle
        ageRating = givenRating
    endprocedure

    public function label()
        return title + " (" + ageRating + ")"
    endfunction
endclass

exampleFilm = new Film("Hidden Figures", "PG")

OCR calls the constructor new. You need to understand what this pseudocode does, but you do not need to reproduce every part of its syntax from memory.

Python equivalent

class Film:
    def __init__(self, title, age_rating):
        self.title = title
        self.age_rating = age_rating

    def label(self):
        return self.title + " (" + self.age_rating + ")"


example_film = Film("Hidden Figures", "PG")

In Python:

• __init__ is the constructor method
• self refers to the particular object currently using the method
• self.title means the title attribute belonging to that object
• calling Film("Hidden Figures", "PG") creates the object and runs its constructor

If another Film object is created, it has its own attribute values even though it uses the same class definition.

Checkpoint: read a class before writing one

Return to the Book example and locate each part:

• class name: Book
• constructor: __init__
• constructor parameters: title and author
• object attributes: self.title and self.author
• method: summary
• two separate objects: first_book and second_book

Notice that the two objects share the same method code but store different titles and authors. This is one reason classes are useful: the program defines the common structure once, then creates as many individual objects as it needs.

Guided modification

First, run the working Student class. Add one change at a time and run it again after each change. This gives you a clear point at which to find an error.

Independent class task

You will then create a Film class from an empty editor:

1. Write the class header.
2. Add __init__ with title and age_rating parameters.
3. Store both values as attributes using self.
4. Add the label() method.
5. Create the required example_film object.

Use the exact attribute, method and object names in the instructions so that the automated checks can locate your work.

Translating meaning between OCR pseudocode and Python

An examination question may describe a class in OCR pseudocode even when you will answer a programming question in Python. Translate the meaning one part at a time.

Constructor

OCR pseudocode:

public procedure new(givenName)
    name = givenName
endprocedure

Readable Python:

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

Both versions receive a name and store it in the new object.

Creating an object

OCR pseudocode:

playerOne = new Player("Maya")

Python:

player_one = Player("Maya")

Both versions create one Player object and keep a reference to it in a variable.

For programming questions in this course, write Python. When reading OCR pseudocode, identify the class, data, behaviour and object creation first, then express the same ideas clearly in Python.

Independent task: model the changing state of a library book

A library book is a useful example of an object whose state changes over time. A newly added book has no borrower, so its borrower attribute starts as None. When a student borrows it, the object records the student's name. Its status() method then produces text based on the current state.

Complete and test the class in this order:

1. In the constructor, store the title and set borrower to None.
2. Make borrow(student_name) update the current object's borrower.
3. In status(), test whether borrower is still None.
4. Return the available message in that case.
5. Otherwise return the message naming the borrower.

Your class must work for both states:

• a newly created book, such as Dune is available
• a borrowed book, such as The Hobbit is on loan to Maya

You do not need to print either result because the checks call the method directly.