Object-Oriented Programming
Home Lesson 5 — Inheritance

Q2 is the bridge into today. Notice the word in the mark scheme: a new class that has all the attributes and methods of its parent. That is a promise, and today you will see exactly how Python keeps it — and the one place where it surprises people.

Atlas of the World, 320 pages
Dune, 412 pages
Genre: Science fiction
Dune

• The same line, two behaviours. For the Book, Item.Describe() runs Book's version — one line. For the Novel, it runs Novel's own version, which first calls the parent's version and then adds the genre — two lines. Python picks the version that belongs to the object's own class. That is polymorphism.
• The last line works even though Novel never defines GetTitle. A novel is a book, so it has every method a book has. Python looks in Novel first, does not find it, and uses Book's.
• The title of the novel is set by Book's constructor, which Novel's constructor calls on its first line. Nothing in Novel mentions __Title at all.

• The arrows point from each child up to the parent — "Acrylic is a Yarn". An arrow from Yarn down to the children is the most common way to lose marks 4 and 5.
• Mark 3 is the one people miss. "Each type of yarn has a method that will display all the information" — and each type holds different information, so each child overrides YarnInfo(). Mix was given to you as the pattern.
• Do not repeat Name, Colour and the rest in the children. They are inherited — exactly as in Python, where the child never re-declares the parent's attributes.
• Notice the … at the end of mark 4 and the start of mark 5: in Cambridge mark schemes that means mark 5 cannot be awarded without mark 4.

class Book:
    def __init__(self, Title, Pages):
        self.__Title = Title        # STRING
        self.__Pages = Pages        # INTEGER

    def GetTitle(self):
        return self.__Title

    def GetPages(self):             # new: the child needs it
        return self.__Pages

    def Describe(self):
        print(self.__Title + ", " + str(self.__Pages) + " pages")

class Novel(Book):
    def __init__(self, Title, Pages, Genre):
        super().__init__(Title, Pages)
        self.__Genre = Genre        # STRING

    def Describe(self):
        super().Describe()
        print("Genre: " + self.__Genre)

    def IsLong(self):
        if self.GetPages() > 400:
            return True
        else:
            return False

class Textbook(Book):
    def __init__(self, Title, Pages, Subject):
        super().__init__(Title, Pages)
        self.__Subject = Subject    # STRING

    def Describe(self):
        super().Describe()
        print("Subject: " + self.__Subject)

Books = [Book("Atlas of the World", 320), Novel("Dune", 412, "Science fiction"),
         Textbook("Cambridge A Level CS", 560, "Computer Science"), Novel("Holes", 233, "Adventure")]
for Item in Books:
    Item.Describe()
print(Books[1].IsLong())
print(Books[3].IsLong())

Expected output:

Atlas of the World, 320 pages
Dune, 412 pages
Genre: Science fiction
Cambridge A Level CS, 560 pages
Subject: Computer Science
Holes, 233 pages
Genre: Adventure
True
False

• The error you met first was 'Novel' object has no attribute '_Novel__Pages' — the private renaming from section 2. The fix is a get method in the parent, used by the child. In the exam the design usually gives you the get methods you need; if a child method needs parent data, look for one.
• return self.GetPages() > 400 on one line is equally correct. The if version makes it obvious that there is a return on every path.
• The loop did not change at all, yet it now handles three classes. Each object brings its own Describe. That is why polymorphism matters: code that works with a parent class keeps working when new children arrive.

• ✓ Class header. class Mix(Yarn): — right relationship, right direction.
• ✓ Parameters. All four, the parent's three first.
• ✗ No call to the parent's constructor. The discrete mark is lost. Worse, the three lines that replace it create new attributes that belong to Mix — _Mix__Name and so on. Yarn's attributes are never set, so the first time a parent method runs on a mix — EditNumberBalls(5), say — it crashes with 'Mix' object has no attribute '_Yarn__NumberBalls'.
• ✓ Percentage is private and its type is evidenced.
• ✗ The override is re-typed, not extended. It forgets the number of balls, so it no longer outputs "all the information that Yarn outputs".
• ✗ "Acrylic: " + self.__Percentage joins a string to an integer — TypeError after two lines of output. In Python, build strings with + and str().

What would have scored

class Mix(Yarn):
    def __init__(self, Name, Colour, NumberBalls, Percentage):
        super().__init__(Name, Colour, NumberBalls)
        self.__Percentage = Percentage    # INTEGER

    def YarnInfo(self):
        super().YarnInfo()
        print("Acrylic: " + str(self.__Percentage) + "%")

The habit to build: the moment you type a child's constructor header, the very next line is super().__init__( with the parent's parameters. And when a design says the child outputs "all the information the parent outputs, then…", the override's first line is super(). plus the method's name. Shorter, safer, and it reaches data the child is not allowed to touch.

Copy this into your editor and build JuniorMember underneath it. Do not change it — the whole point is that the child class adds to it without editing it.

class Member:
    def __init__(self, MemberID, Name, Age):
        self.__MemberID = MemberID   # STRING
        self.__Name = Name           # STRING
        self.__Age = Age             # INTEGER
        self.__Credits = 0           # INTEGER
        self.__Active = True         # BOOLEAN

    def DisplayDetails(self):
        print("Member ID : " + self.__MemberID)
        print("Name      : " + self.__Name)
        print("Age       : " + str(self.__Age))
        print("Credits   : " + str(self.__Credits))
        print("Active    : " + str(self.__Active))

    def GetName(self):
        return self.__Name

    def GetCredits(self):
        return self.__Credits

    def SetAge(self, NewAge):
        self.__Age = NewAge

    def AddCredits(self, Amount):
        NewTotal = self.__Credits + Amount
        if NewTotal > 50:
            NewTotal = 50
        self.__Credits = NewTotal

Accepted alternatives

• MP3: Member.__init__(self, MemberID, Name, Age) in place of super().__init__(MemberID, Name, Age).
• MP8 and MP12: Member.DisplayDetails(self) and Member.AddCredits(self, Amount).
• MP11: if not self.__ConsentGiven:, or testing for True first and putting the message in the else.

Not credited, however good the code looks

• No call to the parent's constructor — MP3 lost, and the program crashes the first time a parent method runs, so MP16 goes too.
• Re-declaring MemberID, Name, Age, Credits or Active in the child — MP3 lost. The parent already has them.
• ConsentGiven taken as a constructor parameter — MP2 and MP5 lost. The design fixes it at FALSE.
• Re-typing the five print lines in the child's DisplayDetails() — MP8 lost, and it crashes on self.__MemberID anyway.
• self.__Name or self.__Credits anywhere in JuniorMember — MP11 or MP12 lost. Private to Member.
• Editing the Member class to add consent — no marks for (c) and (d). The design asks for a child class that overrides; the parent is not yours to change.
• Code pasted as an image — no code marks at all.

Extension — not counted in the 16

• E1 The Lesson 4 Club class used without any change.
• E2 Sara and Ava both added with AddMember(); the output reads Total credits: 60.
• E3 DisplayMember("Ava Brooks") outputs all seven of Ava's detail lines, including the guardian and consent.
• E4 The explanation names polymorphism: Club calls DisplayDetails() on each object, and because Ava is a JuniorMember, her class's overriding version runs.