Object-Oriented Design

Class members and access levels

You have already built classes with a constructor, methods and properties. The A Level specification asks for the vocabulary and the precision on top of that.

Instance and class attributes

An instance attribute belongs to one object, and every object has its own copy. A class attribute belongs to the class itself and is shared by all its objects.

class Student:
    school = "MskProd Academy"         # class attribute: one copy, shared
    count = 0

    def __init__(self, name):
        self.name = name               # instance attribute: one per object
        Student.count += 1

    @classmethod
    def from_text(cls, text):          # an alternative way to construct an object
        name, year = text.split(",")
        student = cls(name)
        student.year = int(year)
        return student

    @staticmethod
    def valid_year(year):              # belongs with the class but needs no object
        return 7 <= year <= 13

a = Student("Asha")
b = Student.from_text("Ben,11")
print(Student.count, a.school, b.year, Student.valid_year(14))

Access levels

Some languages enforce who can see an attribute. Python trusts the programmer and relies on naming conventions:

class Account:
    def __init__(self, owner):
        self.owner = owner
        self._balance = 0
        self.__pin = "4821"

acct = Account("Asha")
print(acct.owner, acct._balance)
print(hasattr(acct, "__pin"), hasattr(acct, "_Account__pin"))     # False True

The private attribute is not hidden, only renamed. It stops accidental access, not a determined programmer, and that is why exam answers should say the intent of encapsulation, not claim Python makes the data unreachable.

Making objects behave like built in types

Special methods let your own class work with len, for loops, indexing and sorting.

class Playlist:
    def __init__(self, name):
        self.name = name
        self._songs = []

    def add(self, song):
        self._songs.append(song)

    def __len__(self):
        return len(self._songs)

    def __iter__(self):
        return iter(self._songs)

    def __getitem__(self, index):
        return self._songs[index]

    def __repr__(self):
        return "Playlist(" + repr(self.name) + ", " + str(len(self)) + " songs)"

p = Playlist("Revision")
p.add("Lofi 1")
p.add("Lofi 2")
print(len(p), p[0], list(p))
print(p)

class Card:
    def __init__(self, rank):
        self.rank = rank
    def __lt__(self, other):
        return self.rank < other.rank
    def __repr__(self):
        return "Card(" + str(self.rank) + ")"

print(sorted([Card(9), Card(2), Card(5)]))

__lt__ is all sorted needs to put your own objects in order. That is polymorphism at its most practical: sorted does not know what a Card is, and does not need to.

Inheritance, overriding and abstract classes

Inheritance lets a class take on the attributes and methods of another. The new class is the subclass (or child, or derived class) and the one it inherits from is the superclass (parent, or base class). It models an is-a relationship: a Circle is a Shape.

A subclass can override a method, supplying its own version, and it can call the original with super().

class Employee:
    def __init__(self, name, base):
        self.name = name
        self.base = base

    def pay(self):
        return self.base

class Manager(Employee):
    def __init__(self, name, base, bonus):
        super().__init__(name, base)       # let the superclass set up its part
        self.bonus = bonus

    def pay(self):                         # overrides Employee.pay
        return super().pay() + self.bonus

staff = [Employee("Asha", 2000), Manager("Ben", 3000, 500)]
for person in staff:
    print(person.name, person.pay())

The loop calls pay() on each object and each gives its own answer. The caller does not check which kind of employee it has. That is polymorphism: the same message, different behaviour, decided by the class of the object.

Abstract classes

Sometimes a superclass exists only to say what every subclass must be able to do. An abstract class has at least one abstract method, with no body, which every concrete subclass has to supply. You cannot create an object from the abstract class itself.

from abc import ABC, abstractmethod

class Shape(ABC):
    def __init__(self, name):
        self.name = name

    @abstractmethod
    def area(self):
        pass

    def describe(self):
        return self.name + " with area " + str(round(self.area(), 2))

class Rectangle(Shape):
    def __init__(self, w, h):
        super().__init__("Rectangle")
        self.w = w
        self.h = h

    def area(self):
        return self.w * self.h

class Circle(Shape):
    def __init__(self, r):
        super().__init__("Circle")
        self.r = r

    def area(self):
        return 3.14159 * self.r ** 2

for shape in [Rectangle(3, 4), Circle(2)]:
    print(shape.describe())

describe is written once, in Shape, and calls self.area(). It works for any shape, including ones that do not exist yet. Trying to build the abstract class itself fails:

# raises: TypeError
from abc import ABC, abstractmethod

class Shape(ABC):
    @abstractmethod
    def area(self):
        pass

shape = Shape()

Composition, aggregation and association

Inheritance is the relationship people reach for first and the one they most often misuse. There are three others, and all of them are has-a or uses-a relationships rather than is-a.

class Engine:
    def __init__(self, horsepower):
        self.horsepower = horsepower

class Car:
    def __init__(self, horsepower):
        self.engine = Engine(horsepower)      # composition: the car creates and owns it

class Team:
    def __init__(self, players):
        self.players = players                # aggregation: they were created elsewhere

class Teacher:
    def mark(self, student):                  # association: uses the student for a moment
        return student + " marked"

car = Car(150)
players = ["Asha", "Ben"]
team = Team(players)
del team
print(car.engine.horsepower, players)         # the players outlive the team
print(Teacher().mark("Asha"))

Favour composition over inheritance

Inheritance locks the relationship in at the moment the class is written. Here is the standard trap:

class Bird:
    def fly(self):
        return "flap flap"

class Penguin(Bird):
    pass

print(Penguin().fly())     # flap flap, but penguins cannot fly

A Penguin is a Bird, so it inherits fly. The model has gone wrong, and every new kind of bird that cannot fly makes it worse. Composition fixes it by treating the behaviour as a part, which the bird has:

class Flies:
    def move(self):
        return "flaps"

class Walks:
    def move(self):
        return "waddles"

class Bird:
    def __init__(self, name, movement):
        self.name = name
        self.movement = movement          # has-a: how it moves is a part

    def move(self):
        return self.name + " " + self.movement.move()

for bird in [Bird("Sparrow", Flies()), Bird("Penguin", Walks())]:
    print(bird.move())

A new way of moving, swimming perhaps, is one new small class, and no existing class changes. The bird's behaviour could even be swapped while the program runs.

Design principles to quote

UML class diagrams

The Unified Modelling Language draws a design before any code is written. A class is a box with three compartments: the name, the attributes and the methods. A symbol in front of each says who can use it.

The lines between classes carry the meaning:

Translating the diagram into code is mechanical. Each box is a class, each - attribute becomes self.__name or self._name, each arrow of inheritance becomes a class that names its parent in brackets, and each diamond becomes an attribute that holds another object.

from abc import ABC, abstractmethod

class Shape(ABC):
    def __init__(self, name):
        self._name = name                  # protected: subclasses use it

    @abstractmethod
    def area(self):                        # + area(): float
        pass

    def get_name(self):
        return self._name

class Circle(Shape):
    def __init__(self, radius):
        super().__init__("Circle")
        self.__radius = radius             # private: only Circle touches it

    def area(self):
        return round(3.14159 * self.__radius ** 2, 2)

c = Circle(2)
print(c.get_name(), c.area())              # Circle 12.57

Key terms you must be able to define

Class attribute

An attribute that belongs to the class itself and is shared by every object of that class.

Instance attribute

An attribute that belongs to one object, so each object has its own copy.

Encapsulation

Bundling data with the methods that act on it, and restricting direct access to the data from outside the class.

Inheritance

A mechanism by which a subclass acquires the attributes and methods of a superclass.

Overriding

Providing a new version of an inherited method in a subclass.

Polymorphism

The ability for the same method call to behave differently depending on the class of the object it is called on.

Abstract class

A class that cannot be instantiated, which declares methods that its subclasses must implement.

Composition

A relationship in which one object is made of other objects that it owns, and which cannot exist without it.

Aggregation

A relationship in which one object holds other objects that can exist independently of it.

Association

A relationship in which one object uses another.

UML class diagram

A diagram that shows classes, their attributes and methods, and the relationships between them.

Flashcards

Say the definition out loud before you flip the card. Retrieving it from memory is what builds recall, reading it again is not.

Reach the top grade on this topic

Object oriented answers reward exact vocabulary tied to the code in front of you.

• Define encapsulation, inheritance and polymorphism separately, then show each in the given code
• Say whether a relationship is is-a, or has-a, and name it: inheritance, composition or aggregation
• Use the correct UML symbols for public, private and protected, and draw the arrow for inheritance towards the parent
• In a design question, justify a choice: composition because behaviour might change, inheritance because it is truly is-a
• Write super().__init__ in a subclass constructor, and mark abstract methods as abstract

Mistakes that cost marks here

class Vehicle:
    def __init__(self, registration):
        self.__registration = registration
        self._speed = 0

    def accelerate(self, amount):
        self._speed += amount

    def get_speed(self):
        return self._speed

class Lorry(Vehicle):
    def __init__(self, registration, load):
        super().__init__(registration)
        self.load = load

    def accelerate(self, amount):
        self._speed = min(self._speed + amount, 60)

truck = Lorry("AB12 CDE", 8000)
truck.accelerate(45)
truck.accelerate(45)
print(truck.get_speed())