How to invoke the super constructor?

super() returns a parent-like object in new-style classes:

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

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

B()

• just of curiosity why does super(B,self) require both B and self to be mentioned? isn't this redundant? shouldn't self contain a reference to B already? - Mike
• No, because self might actually be an instance of C, a child of B. - Ignacio Vazquez-Abrams
• @Luc: That's because the class was declared incorrectly. See my answer. - Ignacio Vazquez-Abrams
• With respect to the documentation of super(), you should be able to write super().__init__() wothout arguments. - JojOatXGME
• @JojOatXGME: In 3.x, yes. 2.x still needs the arguments. - Ignacio Vazquez-Abrams

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

Python-2.x

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

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

Python-3.x

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

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

super() is now equivalent to super(<containing classname>, self) as per the docs.

With Python 2.x old-style classes it would be this:

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

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

• This won't work for new style classes? - kdbanman
• @kdbanman: This will work with new-style classes, but one of the reasons to use new-style classes is to not have to do it this way. You can use super and not have to directly name the class you're inheriting from. - Gabe

One way is to call A's constructor and pass self as an argument, like so:

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

The advantage of this style is that it's very clear. It call A's constructor. The downside is that it doesn't handle diamond-shaped inheritance very well, since you may end up calling the shared base class's constructor twice.

Another way is to use super(), as others have shown. For single-inheritance, it does basically the same thing as letting you call the parent's constructor.

However, super() is quite a bit more complicated under-the-hood and can sometimes be counter-intuitive in multiple inheritance situations. On the plus side, super() can be used to handle diamond-shaped inheritance. If you want to know the nitty-gritty of what super() does, the best explanation I've found for how super() works is here (though I'm not necessarily endorsing that article's opinions).

• Is there any need to call A's constructor like this when it doesn't take any variable(ignoring self) as an argument? I mean the code works fine without A.__init__(self) line. - Red Floyd

I use the following formula that extends previous answers:

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

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

B()

This way you don't have to repeat the name of the class in the call to super. It can come handy if you are coding a large number of classes, and want to make your code in the constructor methods independent of the class name.

• But you will get infinitive recursion if decide to extend B with C, and self.__class__ points to C(B) instead of B(A), so super(self.__class__, self) points back to B instead of A. - dened
• This will lead to infinite recursion errors when you subclass B. Do not use self.__class__ or type(self), either pass in an explicit class (B here) or, in Python 3, use super() without arguments. - Martijn Pieters♦

Short Answer

super(DerivedClass, self).__init__()

Long Answer

What does super() do?

It takes specified class name, finds its base classes (Python allows multiple inheritance) and looks for the method (__init__ in this case) in each of them from left to right. As soon as it finds method available, it will call it and end the search.

How do I call init of all base classes?

Above works if you have only one base class. But Python does allow multiple inheritance and you might want to make sure all base classes are initialized properly. To do that, you should have each base class call init:

class Base1:
  def __init__():
    super(Base1, self).__init__()

class Base2:
  def __init__():
    super(Base2, self).__init__()

class Derived(Base1, Base2):
  def __init__():
    super(Derived, self).__init__()

What if I forget to call init for super?

The __init__ for base class is not called. There is no implicit constructor calls like in C++ and Java.