That is correct. Note that you can also call the __init__ method directly on the Base class, like so:

class Child(Base):
    def __init__(self, something_else):
        Base.__init__(self, value = 20)
        self.something_else = something_else

That's the way I generally do it. But it's discouraged, because it doesn't behave very well in the presence of multiple inheritance. Of course, multiple inheritance has all sorts of odd effects of its own, and so I avoid it like the plague.

In general, if the classes you're inheriting from use super, you need to as well.

In C++, constructors are special operators. There is special syntax for calling a base class constructor:

class A { ... };

class B: public A {
public:
  B() : A() { ... }
  //  ^^^^^
};

If the base constructor is not called explicitly, the default constructor for the base class will be called automatically.

This is important for C++'s memory model and data model:

• failing to call the base constructor could lead to uninitialised memory, and would definitely lead to UB
• classes may or may not be default constructible, which affects how explicit you need to be

Python is a very different language. It has no concept of default constructors. It has no concept of uninitialised memory. And Python constructors are just an ordinary initialization method (well, as ordinary as a dunder-method can be). There is no special syntax for calling the base class init method, it's just the same as calling any other base class method.

This kind of fits into the general Python theme of having a minimal syntax, but complex, flexible semantics. The language doesn't force you to initialize your objects properly, just as it doesn't force you to only assign specific types to some variable. As the language itself won't help you, you have to use linters to check for common mistakes.

Note that Python's flavour of multiple inheritance makes it difficult or impossible to handle "base" class constructors automatically. If the class you are writing is one of multiple bases in a multiple inheritance hierarchy, then the super().__init__() call may not go to this classes' base but possibly to an unrelated sibling class. Handling that properly requires a conscious design effort.

Of course, the best move is not to play. As a dynamic language, there are very few circumstances where inheritance is the best solution in Python.

In line with the other answers, there are multiple ways to call super class methods (including the constructor), however in Python 3 the process has been simplified:

Python 3

class A(object):
    def __init__(self):
        print("world")

class B(A):
    def __init__(self):
        print("hello")
        super().__init__()

Python 2

In Python 2, you have to call the slightly more verbose version super(<containing classname>, self), which is equivalent to super()as per the docs.

class A(object):
    def __init__(self):
        print "world"

class B(A):
    def __init__(self):
        print "hello"
        super(B, self).__init__()

Python recommends using super().

Python 2:

super(Instructor, self).__init__(name, year)

Python 3:

super().__init__(name, year)

is the sole purpose of doing that is to just ensure that the base class is initialized?

Well yes, but what do you mean, just?

Assuming your base class has a reason to exist, it must do something.

Unless it's just a convenient collection of @staticmethod functions, whatever it does might depend on its __init__ having been called, because that's how class objects work.

Even if your base class has an empty __init__ today, it's sensible to call it, in case that changes in the future.

Or, would there be other possible use cases?

The use case is to make sure that the base class part of your object is correctly initialized. Without that, you can't safely call any of its non-static methods.

In principle your base class could do something tricksy in its __init__ (starting a background thread, or registering the instance with some singleton, or ... whatever). So yes, there could be effects other than just assigning instance variables, but this is still part of initializing an object of that base class.

Does python call by default the base class constructor's when running the derived class' one? Do I have to implicitly do it inside the derived class constructor?

No and yes.

This is consistent with the way Python handles other overridden methods - you have to explicitly call any method from the base class that's been overridden if you want that functionality to be used in the inherited class.

Your constructor should look something like this:

def __init__(self, numberOfInputs, numberOfHiddenNeurons, numberOfOutputs):
    NeuralNetworkBase.__init__(self, numberOfInputers, numberOfHiddenNeurons, numberOfOutputs)
    self.outputLayerDeltas = numpy.zeros(shape = (numberOfOutputs))
    self.hiddenLayerDeltas = numpy.zeros(shape = (numberOfHiddenNeurons))

Alternatively, you could use Python's super function to achieve the same thing, but you need to be careful when using it.