Introducing the super() Function

I guess you could also take the code de-duplication further by moving the point-quantity checking code into the parent class. Here’s how I think this could be done:

class WrongNumberOfPoints(Exception):
    pass

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

class Shape:
    def __init__(self, points, num_points):
        self.num_points = num_points
        for point in points:
            if not isinstance(point, Point):
                raise TypeError("your error message here")
        if len(points) != self.num_points:
            raise WrongNumberOfPoints
        self.points = points

class Square(Shape):
    NUM_POINTS = 4
    def __init__(self, points):
        super().__init__(points, Square.NUM_POINTS)

class Pentagon(Shape):
    NUM_POINTS = 5
    def __init__(self, points):
        super().__init__(points, Pentagon.NUM_POINTS)

In Shape’s __init__, num_points could either be left as is, or could possibly be made safer by setting it to a default of None, so that it’s an optional argument, in case anyone ever instantiates Shape directly. It depends on whether the Shape class is ever likely to be instantiated directly, or if it will only ever be inherited from.

Is this valid / worth doing?

Hi Ash D,

good idea to move the check to the parent class :)

But there’s an issue of putting the check in the init method like that:

Let’s say you want to create a shape that doesn’t have it’s own class. In that case you need to instantiate the Shape class. By setting a default value of None for num_points, the check will raise the WrongNumberOfPoints error every time no num_points is given, because even an empty list of points has a length of 0 which is not None.

You could bypass that by always using len(points) as the second argument if you’re using the Shape class directly.

Another approach, especially if the check is a bit more complicated than this one, could be to create a new method for the check inside of the Shape class. In this example, I used a decorator to create a static method for checking the number of points, if needed:

...
class Shape:
    def __init__(self, points):
    for point in points:
        if not isinstance(point, Point):
            raise TypeError("All points should be members of the Point class!")
    self.points = points

    @staticmethod
    def check_point_count(points, count):
        if len(points) != count:
            raise WrongNumberOfPoints

class Square(Shape):
    def __init__(self, points):
        super().check_point_count(points, 4)
        super().__init__(points)

You can call every method of the parent class using super(), so that might be a possible approach to only write the code for the check once.

👉🏻 There is a tutorial on the Instance, Class and Static methods here on RealPython.

Hi

If the shape class has the check whther it is a point, then why square or pentagon is not inheriting the check from the class? without using super function.

Thanks