Understanding calling parent __init__ in subclass

Question

New to Python and was curious if someone could explain, in layman's terms as much as possible, why it is that, when you're creating a subclass, you still need to call the parent initialization function?

Let's say you have a parent class like this:

class Pet(object):

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

    def getName(self):
        return self.name

    def getSpecies(self):
        return self.species

    def __str__(self):
        return "%s is a %s" % (self.name, self.species)

Then I want to make a subclass called "Dog" that obviously uses some of the functions in the parent class. My research is telling me that I need to do something like this:

class Dog(Pet):

    def __init__(self, name, chases_cats):
        Pet.__init__(self, name, "Dog")
        self.chases_cats = chases_cats

    def chasesCats(self):
        return self.chases_cats

But why, if I'm passing the parent class as an argument when defining the subclass, do I need to call the parent's __init__ ? Isn't this automatically passed to the subclass by virtue of the fact that it's a subclass?

I'm sure I'm missing something obvious here in my understanding, but it's just not clicking for me.

Answer 1

What I'm asking is: why does it work that way? If you're inheriting from the parent class, doesn't it stand to reason that you're then inheriting everything from the parent class, including the __init__ ?

Not if you're overriding it. If your subclass doesn't define its own __init__, then the superclass __init__ is indeed called. But if the subclass does define its own __init__, then you're overriding it, so Python doesn't make asusumptions about how or whether you want to call the superclass implementation.

This gives you additional flexibility. If the superclass __init__ were called automatically, it would have to be uniformly called before or after the subclass __init__. But since it's not called automatically, you can call it whenever you like. You can call it at the beginning of the subclass __init__, at the end, somewhere in the middle, or not at all. This means that your subclass can either "set up" things before the superclass method acts, or "tweak" things after the superclass method acts, or do both, or completely replace the superclass functionality.

Also, if the superclass implementation were called automatically, it would be unclear what to do if the subclass didn't accept the same arguments as the superclass. With explicit superclass calling, your subclass can accept more or fewer arguments than its superclass, and can decide itself what to pass when calling the superclass.