Blog

One of the cornerstones of OOP is the concept of inheritance. The idea is best illustrated with an example.

Suppose we have a number of objects that all have one or more properties in common. An example from geometry is that of the regular polygons. All such polygons have a number of sides all the same length, and they also all have an area. We can extract the properties that are common to all these polygons and encapsulate them in a class that we’ll call Polygon.

Although any given polygon will have a fixed number of sides, and a fixed length for each side, the formulas for calculating the area  of each type of regular polygons depends on the type of polygon (triangle, square, pentagon, etc). We can therefore create a separate class for each type of polygon, in which the formula for the area of that type of polygon is given. The Polygon class, containing the common properties, is known as the base class, and each of the specialized classes for each type of polygon is said to inherit the base class. These specialized classes are called derived classes or subclasses of the base class.

Proper use of inheritance

It’s worth pointing out that inheritance should be used only in cases where you have a number of objects that are each a specialized type of some more general type of object, as we’ve seen here with polygons. I’ve seen some examples on the web (that shall remain nameless) that give examples of inheritance that are, frankly, just plain wrong. For example, one site gives an example where a Cube class inherits a Square class, presumably because cubes have square faces. However, a cube is not a specialized type of square; it’s a completely different type of object (3-d versus 2-d), so inheritance is not appropriate here. It makes sense for a Cube class to contain a Square object (a process known as composition) but not for a Cube class to inherit a Square class.

A test that is useful when deciding whether or not to use inheritance is to ask yourself: is one type of object a specialized type of a more general type of object? Or, to put it more succinctly, does it pass the ‘is-a-type-of’ test? If not, don’t use inheritance.

Polygon classes

It’s easiest to see how inheritance works by looking at the code for this example. Here I’m using the area formulas that we met earlier when discussion lambda functions. Here’s the code:

# In file Polygon.py 

from math import *

class Polygon:
    def __init__(self, numSides, side):
        self.numSides = numSides
        self.side = side
        self.area = 0

    def PrintSides(self):
        print(f'Sides = {self.numSides} of length {self.side:.4f}', end='; ')

    def PrintArea(self):
        print(f'Area = {self.area:.4f}')

class Triangle(Polygon):
    def __init__(self, s):
        Polygon.__init__(self, side = s, numSides = 3)
        self.area = sqrt(3) * self.side ** 2 / 4

class Square(Polygon):
    def __init__(self, s):
        Polygon.__init__(self, side = s, numSides = 4)
        self.area = self.side ** 2

class Pentagon(Polygon):
    def __init__(self, s):
        Polygon.__init__(self, side = s, numSides = 5)
        self.area = sqrt(5 * (5 + 2 * sqrt(5))) * self.side ** 2 / 4

On lines 5 through 15 we define the Polygon base class. We see that the constructor on line 6 expects the number of sides and side length of the polygon to be passed into it, but it just sets the area of the polygon to zero, since we don’t know in advance what formula to use to calculate the area. Following the constructor there are a couple of methods that just print out the values.

Line 17 shows our first example of a derived class. The syntax for inheriting a base class is class <Derived>(<Base>):, where <Derived> is the name of the derived class, and <Base> (in parentheses) is the name of the class being inherited. As usual, we must end the line with a colon.

In this example, we provide only a constructor for Triangle, on line 18. The constructor requires only one argument, namely the side length s. The number of sides for a triangle is, of course, 3 so we don’t need to input that. In general, a derived class can have any number of methods, just as with any other class. More on this later.

By inheriting Polygon, Triangle inherits all its variables and methods as well. Thus the PrintSides() and PrintArea() methods defined in the Polygon class become part of Triangle, and can be called by any Triangle object.

The Polygon constructor is also accessible to Triangle, as is shown on line 19. We can access a method from a base class by prefixing the method’s name with the name of the base class, in this case, Polygon. Thus the base class constructor is called, which initializes the attributes numSides, side and area. After this, on line 20, we calculate the triangle’s area.

The rest of this file creates two more derived classes, one for squares and one for pentagons. The process is exactly the same as for triangles.

The super() method

There is another way of referring to a base class’s methods than that of explicitly naming the base class, as we did in the previous example. This uses the built-in super() method.

super() has given rise to a lot of controversy in the Python community, as its use can lead to hard-to-find bugs in more complex programs. These types of programs usually involve multiple inheritance (where a derived class inherits more than one base class). We’ll leave a discussion of these situations until later; here we’ll just illustrate how super() can be used in the a simple case of single inheritance.

We can modify the above program to use super() as follows:

# In file Polygon.py

from math import *

class Polygon:
    def __init__(self, numSides, side):
        self.numSides = numSides
        self.side = side
        self.area = 0

    def PrintSides(self):
        print(f'Sides = {self.numSides} of length {self.side:.4f}', end='; ')

    def PrintArea(self):
        print(f'Area = {self.area:.4f}')

class Triangle(Polygon):
    def __init__(self, s):
        super().__init__(side = s, numSides = 3)
        self.area = sqrt(3) * self.side ** 2 / 4

class Square(Polygon):
    def __init__(self, s):
        super().__init__(side = s, numSides = 4)
        self.area = self.side ** 2

class Pentagon(Polygon):
    def __init__(self, s):
        super().__init__(side = s, numSides = 5)
        self.area = sqrt(5 * (5 + 2 * sqrt(5))) * self.side ** 2 / 4

The only changes we’ve made are to replace the explicit calls to the Polygon constructor from the derived classes with calls using super(). On line 19, for example, we make a call to super(). What super() does is to create and return a proxy object from the base class, so in this case, it creates a temporary object of the Polygon class. This proxy is then used to call the constructor from the Polygon class, and you can see on line 19 that we pass into this constructor values for side and numSides (by using keyword arguments). Thus the constructor in Polygon (on line 6) performs the initialization of these two variables for the Triangle object.

Notice that we do not pass self as an argument to the base class constructor when using super(), as super() implicitly passes the proxy object to the base class along with the other arguments in the constructor.

If your programs involve only single inheritance, it’s largely a matter of taste whether you use explicit naming of the base class or the super() method when calling base class methods.

Overriding class methods

The example above in which the constructor was overridden in a derived class is just a special case of method overriding. Any class method can be overridden in a derived class just by giving the method the same name and argument list in the derived class as it has in the base class. The base class version of the method can be called using super(), just as with the constructor. An example of this is contained in Exercise 2 below.

Exercise 1

Why does the above example of the Polygon class and its derived classes not work if we swap, for example, lines 19 and 20?

Testing the derived classes

To try out the classes defined above, we can create some objects from them. In the main file of the project, we have the code:

from Polygon import *

tri = Triangle(5)
tri.PrintSides()
tri.PrintArea()

The output is Sides = 3 of length 5.0000; Area = 10.8253. Note that we needed to specify only the side length (5) when creating a Triangle object; everything else is handled by the constructors.

A slightly more sophisticated example is this:

from Polygon import *
from random import *

polyClass = [Triangle, Square, Pentagon]
polygons = [polyClass[randint(0,2)](random() * 10) for i in range(0, 10)]

for poly in polygons:
    poly.PrintSides()
    poly.PrintArea()

This little program generates 10 random shapes, each of which has a side length chosen as a random number between 0 and 10. On line 4, we create a list containing the names of the derived classes. On line 5, we use list comprehension to create the list of random polygons. The syntax here begins with polyClass[randint(0,2)], which selects at random one of the 3 members of the polyClass list of derived classes. We then follow it with (random() * 10) which provides the value of the side length to be passed to the constructor.

Typical output is:

Sides = 4 of length 8.6104; Area = 74.1391
Sides = 4 of length 2.7758; Area = 7.7049
Sides = 4 of length 3.7817; Area = 14.3012
Sides = 3 of length 1.8690; Area = 1.5125
Sides = 4 of length 3.4582; Area = 11.9589
Sides = 3 of length 9.6639; Area = 40.4393
Sides = 4 of length 5.3839; Area = 28.9869
Sides = 5 of length 2.1330; Area = 7.8278
Sides = 5 of length 1.7540; Area = 5.2932
Sides = 3 of length 2.3413; Area = 2.3736

Exercise 2

As part of the design for an adventure game, we’ll look at the code for representing some items carried by the adventurer.

We expect all items to have some properties in common, such as weight and initial location (where they are found in the game). We’ll represent both the weight and location by ints (you can think of the location number as the index of a room or other location in the game). Thus we will need a base class called Item which has data fields for the weight and location of the object.

The game will have a variety of different types of items. We’ll consider two here: Armour and Food. Both of these have weight and location fields, so they can each inherit Item. We’ll add a field called Armour Class (or just ac) to the armour, which is an int specifying how much protection the armour provides. A food item has a Health field, specifying by how much the adventurer’s health is increased (or possibly decreased, if the food is poisoned) when eaten.

To implement encapsulation, the data fields should be private, with appropriate getter and setter methods.

Finally, we want a method in each class that returns a string describing the item. The string should contain the item’s type (class name), and a list of all the data fields and their values for that item. Use method overriding to provide versions of this method in the base and derived classes.

Write some code for these 3 classes, each in its own file. Try to minimize the amount of code duplication by placing code for properties and actions common to all item classes in the base Item class.

To test the code, write a main program that prints a menu of the item types available (we’ll allow only Armour and Food types to be selected, so the base Item class shouldn’t be listed). The user selects an item type and is then prompted to input the data for that item. The user should be allowed to enter as many items as required, and then type ‘quit’ to stop entering items. At this point, a list of all items selected should be printed.

Hint: you may find the built-in function type() and the built-in data field __name__ useful. Do a bit of online research to learn about them.

class Item:
    """ base class for items in the game """
    def __init__(self):
        self.__weight = input('Weight: ')
        self.__location = input('Location: ')

    def setWeight(self, weight):
        self.__weight = weight

    def getWeight(self):
        return self.__weight

    def setLocation(self, location):
        self.__location = location

    def getLocation(self):
        return self.__location

    def PrintProps(self):
        return type(self).__name__ + '; Weight: ' + self.getWeight() + \
                '; Location: ' + self.getLocation()

from Item import *

class Armour(Item):
    """an item of armour"""
    def __init__(self):
        super().__init__()
        self.__ac = input('Armour class: ')

    def getAc(self):
        return self.__ac

    def setAc(self, ac):
        self.__ac = ac

    def PrintProps(self):
        props = super().PrintProps()
        props += '; Armour class: ' + self.getAc()
        return props

from Item import *

class Food(Item):
    """an item of food"""

    def __init__(self):
        super().__init__()
        self.__health = input('Health: ')

    def getHealth(self):
        return self.__health

    def setHealth(self, health):
        self.__health = health

    def PrintProps(self):
        props = super().PrintProps()
        props += '; Health: ' + self.getHealth()
        return props

from Armour import *
from Food import *

itemTypes = { 1:Armour, 2:Food }
itemClasses = [ x.__name__ for x in itemTypes.values() ]

items = []
while True:
    print(f'Available types:')
    for num in itemTypes.keys():
        num = int(num)
        print(f'{num}. {itemClasses[num - 1]}')
    choice = input('\nChoose type: ')
    if choice == 'quit':
        break
    choice = int(choice)
    if choice <= len(itemClasses):
        items += [ itemTypes[choice]() ]

    print('\n')

carried = [i.PrintProps() for i in items]
print('\nCarried:')
for c in carried:
    print(c)

Available types:
1. Armour
2. Food

Choose type: 1
Weight: 500
Location: 2
Armour class: 5


Available types:
1. Armour
2. Food

Choose type: 2
Weight: 10
Location: 4
Health: 50


Available types:
1. Armour
2. Food

Choose type: quit

Carried:
Armour; Weight: 500; Location: 2; Armour class: 5
Food; Weight: 10; Location: 4; Health: 50