Why is `super()` used?

Is there a difference between using `Base.__init__` and `super().__init__`?

    class Base(object):
    	def __init__(self):
    		print &quot;Base created&quot;
    		
    class ChildA(Base):
    	def __init__(self):
    		Base.__init__(self)
    		
    class ChildB(Base):
    	def __init__(self):
    		super(ChildB, self).__init__()
    		
    ChildA() 
    ChildB()



Understanding Python super() with __init__() methods

I came across PECS (short for *Producer `extends` and Consumer `super`*) while reading up on generics. 

Can someone explain to me how to use PECS to resolve confusion between `extends` and `super`?

What is PECS (Producer Extends Consumer Super)?

What&#39;s the difference between:

    class Child(SomeBaseClass):
    	def __init__(self):
    		super(Child, self).__init__()
    		
and:
    		
    class Child(SomeBaseClass):
    	def __init__(self):
    		SomeBaseClass.__init__(self)
    		
I&#39;ve seen `super` being used quite a lot in classes with only single inheritance. I can see why you&#39;d use it in multiple inheritance but am unclear as to what the advantages are of using it in this kind of situation.

What does &#39;super&#39; do in Python? - difference between super().__init__() and explicit superclass __init__()

The following use of `super()` raises a TypeError: why?

    &gt;&gt;&gt; from  HTMLParser import HTMLParser
    &gt;&gt;&gt; class TextParser(HTMLParser):
    ...     def __init__(self):
    ...         super(TextParser, self).__init__()
    ...         self.all_data = []
    ...         
    &gt;&gt;&gt; TextParser()
    (...)
    TypeError: must be type, not classobj

There is a similar question on StackOverflow: https://stackoverflow.com/questions/489269/python-super-raises-typeerror-why, where the error is explained by the fact that the user class is not a new-style class.  However, the class above is a new-style class, as it inherits from `object`:

    &gt;&gt;&gt; isinstance(HTMLParser(), object)
    True

What am I missing? How can I use `super()`, here?

Using `HTMLParser.__init__(self)` instead of `super(TextParser, self).__init__()` would work, but I would like to understand the TypeError.

PS: Joachim pointed out that being a new-style-class instance is not equivalent to being an `object`. I read the opposite many times, hence my confusion (example of new-style class instance test based on `object` instance test: https://stackoverflow.com/revisions/2655651/3).


super() raises &quot;TypeError: must be type, not classobj&quot; for new-style class

Say I have a multiple inheritance scenario:

    class A(object):
        # code for A here

    class B(object):
        # code for B here

    class C(A, B):
        def __init__(self):
            # What&#39;s the right code to write here to ensure 
            # A.__init__ and B.__init__ get called?

There&#39;s two typical approaches to writing `C`&#39;s `__init__`:

 1. (old-style) `ParentClass.__init__(self)`
 2. (newer-style) `super(DerivedClass, self).__init__()`

However, in either case, if the parent classes (`A` and `B`) [don&#39;t follow the same convention, then the code will not work correctly](http://fuhm.org/super-harmful/) (some may be missed, or get called multiple times).

So what&#39;s the correct way again?  It&#39;s easy to say &quot;just be consistent, follow one or the other&quot;, but if `A` or `B` are from a 3rd party library, what then?  Is there an approach that can ensure that all parent class constructors get called (and in the correct order, and only once)?

Edit: to see what I mean, if I do:

    class A(object):
        def __init__(self):
            print(&quot;Entering A&quot;)
            super(A, self).__init__()
            print(&quot;Leaving A&quot;)
            
    class B(object):
        def __init__(self):
            print(&quot;Entering B&quot;)
            super(B, self).__init__()
            print(&quot;Leaving B&quot;)
    
    class C(A, B):
        def __init__(self):
            print(&quot;Entering C&quot;)
            A.__init__(self)
            B.__init__(self)
            print(&quot;Leaving C&quot;)

Then I get:

    Entering C
    Entering A
    Entering B
    Leaving B
    Leaving A
    Entering B
    Leaving B
    Leaving C

Note that `B`&#39;s init gets called twice.  If I do: 

    class A(object):
        def __init__(self):
            print(&quot;Entering A&quot;)
            print(&quot;Leaving A&quot;)
            
    class B(object):
        def __init__(self):
            print(&quot;Entering B&quot;)
            super(B, self).__init__()
            print(&quot;Leaving B&quot;)
    
    class C(A, B):
        def __init__(self):
            print(&quot;Entering C&quot;)
            super(C, self).__init__()
            print(&quot;Leaving C&quot;)

Then I get: 

    Entering C
    Entering A
    Leaving A
    Leaving C

Note that `B`&#39;s init never gets called.  So it seems that unless I know/control the init&#39;s of the classes I inherit from (`A` and `B`) I cannot make a safe choice for the class I&#39;m writing (`C`).

Calling parent class __init__ with multiple inheritance, what&#39;s the right way?

Is `super()` used to call the parent constructor?
Please explain `super()`.

super() in Java

I get some error that I can&#39;t figure out. Any clue what is wrong with my sample code?

    class B:
        def meth(self, arg):
            print arg
    
    class C(B):
        def meth(self, arg):
            super(C, self).meth(arg)
    
    print C().meth(1)

I got the sample test code from help of &#39;super&#39; built-in method. 

Here is the error:

    Traceback (most recent call last):
      File &quot;./test.py&quot;, line 10, in ?
        print C().meth(1)
      File &quot;./test.py&quot;, line 8, in meth
        super(C, self).meth(arg)
    TypeError: super() argument 1 must be type, not classobj

FYI, here is the help(super) from python itself:

    Help on class super in module __builtin__:
    
    class super(object)
     |  super(type) -&gt; unbound super object
     |  super(type, obj) -&gt; bound super object; requires isinstance(obj, type)
     |  super(type, type2) -&gt; bound super object; requires issubclass(type2, type)
     |  Typical use to call a cooperative superclass method:
     |  class C(B):
     |      def meth(self, arg):
     |          super(C, self).meth(arg)
     |



super() fails with error: TypeError &quot;argument 1 must be type, not classobj&quot; when parent does not inherit from object

Isn&#39;t this one automatically put by the compiler if I don&#39;t put it in a subclass&#39;s constructor?

That means I don&#39;t even need to care about it? In some articles they put it out.

And if I&#39;ve got one constructor with arguments, will this be the constructor, or does it take a constructor without argument list? 

Is it unnecessary to put super() in constructor?

In Python 3.x, [`super()`][1] can be called without arguments:

&lt;!-- language: python --&gt;
 
    class A(object):
        def x(self):
             print(&quot;Hey now&quot;)
    
    class B(A):
        def x(self):
            super().x()

&lt;!-- language: none --&gt;

    &gt;&gt;&gt; B().x()
    Hey now
    
In order to make this work, some compile-time magic is performed, one consequence of which is that the following code (which rebinds `super` to `super_`) fails:

&lt;!-- language: python --&gt;

    super_ = super
    
    class A(object):
        def x(self):
            print(&quot;No flipping&quot;)
    
    class B(A):
        def x(self):
            super_().x()

&lt;!-- language: none --&gt;

    &gt;&gt;&gt; B().x()
    Traceback (most recent call last):
      File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
      File &quot;&lt;stdin&gt;&quot;, line 3, in x
    RuntimeError: super(): __class__ cell not found

Why is `super()` unable to resolve the superclass at runtime without assistance from the compiler? Are there practical situations in which this behaviour, or the underlying reason for it, could bite an unwary programmer?

... and, as a side question: are there any other examples in Python of functions, methods etc. which can be broken by rebinding them to a different name?

  [1]: http://docs.python.org/3.3/library/functions.html#super

Why is Python 3.x&#39;s super() magic?

In Python 2.5, the following code raises a `TypeError`:

    &gt;&gt;&gt; class X:
          def a(self):
            print &quot;a&quot;

    &gt;&gt;&gt; class Y(X):
          def a(self):
            super(Y,self).a()
            print &quot;b&quot;

    &gt;&gt;&gt; c = Y()
    &gt;&gt;&gt; c.a()
    Traceback (most recent call last):
      File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
      File &quot;&lt;stdin&gt;&quot;, line 3, in a
    TypeError: super() argument 1 must be type, not classobj

If I replace the `class X` with `class X(object)`, it will work. What&#39;s the explanation for this?

Python super() raises TypeError

    public class SuperClass
    {
    	public void method1()
    	{
    		System.out.println(&quot;superclass method1&quot;);
    		this.method2();
    	}
    	
    	public void method2()
    	{
    		System.out.println(&quot;superclass method2&quot;);
    	}
    		
    }
    
    public class SubClass extends SuperClass
    {
    	@Override
    	public void method1()
    	{
    		System.out.println(&quot;subclass method1&quot;);
    		super.method1();
    	}
    	
    	@Override
    	public void method2()
    	{
    		System.out.println(&quot;subclass method2&quot;);
    	}
    }
    
    
    
    public class Demo 
    {
    	public static void main(String[] args) 
    	{
    		SubClass mSubClass = new SubClass();
    		mSubClass.method1();
    	}
    }

my expected output:

&gt; subclass method1  
&gt; superclass method1  
&gt; superclass method2  

actual output:

&gt; subclass method1  
&gt; superclass method1  
&gt; subclass method2


I know technically I have overriden a public method, but I figured that because I was calling the super, any calls within the super would stay in the super, this isn&#39;t happening. Any ideas as to how I can make it happen?


Java: Calling a super method which calls an overridden method

I have created an Android Application Project and in MainActivity.java &gt; `onCreate()` it is calling `super.onCreate(savedInstanceState)`.

As a beginner, can anyone explain what is the purpose of the above line?

super.onCreate(savedInstanceState);

I&#39;m trying to learn the super() function in Python.

I thought I had a grasp of it until I came over this example (2.6) and found myself stuck.

[http://www.cafepy.com/article/python_attributes_and_methods/python_attributes_and_methods.html#super-with-classmethod-example][1]

    Traceback (most recent call last):
      File &quot;&lt;stdin&gt;&quot;, line 1, in &lt;module&gt;
      File &quot;test.py&quot;, line 9, in do_something
        do_something = classmethod(do_something)
    TypeError: unbound method do_something() must be called with B instance as first argument (got nothing instead)
    &gt;&gt;&gt;

It wasn&#39;t what I expected when I read this line right before the example:

&lt;blockquote&gt;If we&#39;re using a class method, we don&#39;t have an instance to call super with. Fortunately for us, super works even with a type as the second argument. --- The type can be passed directly to super as shown below. &lt;/blockquote&gt;

Which is exactly what Python tells me is not possible by saying that do_something() should be called with an instance of B.

[1]: https://web.archive.org/web/20170820065901/http://www.cafepy.com/article/python_attributes_and_methods/python_attributes_and_methods.html#super-with-classmethod-example

Using super with a class method

Let&#39;s say I have a base class named `Entity`.  In that class, I have a static method to retrieve the class name:

    class Entity {
        public static String getClass() {
            return Entity.class.getClass();
        }
    }

Now I have another class extend that.

    class User extends Entity {
    }

I want to get the class name of User:

    System.out.println(User.getClass());

My goal is to see &quot;com.packagename.User&quot; output to the console, but instead I&#39;m going to end up with &quot;com.packagename.Entity&quot; since the Entity class is being referenced directly from the static method.

If this wasn&#39;t a static method, this could easily be solved by using the `this` keyword within the `Entity` class (i.e.: `return this.class.getClass()`).  However, I need this method to remain static.  Any suggestions on how to approach this?

Getting the name of a sub-class from within a super-class

I was wondering, when creating new `Activity` classes and then overriding the `onCreate()` method, in eclipse I always get auto added: `super.onCreate()`. How does this happen? Is there a java keyword in the abstract or parent class that forces this?

I don&#39;t know if it is illegal not to call the super class, but I remember in some methods that I got a exception thrown for not doing this. Is this also built-in into java? Can you use some keyword to do that? Or how is it done?

How to force derived class to call super method? (Like Android does)

I&#39;m currently learning about class inheritance in my Java course and I don&#39;t understand when to use the `super()` call?

Edit:  
I found this example of code where &lt;code&gt;super.*variable*&lt;/code&gt; is used:

    class A
    {
        int k = 10;
    }
    
    class Test extends A
    {
    	public void m() {
    		System.out.println(super.k);
    	}
    }


So I understand that here, you must use `super` to access the `k` variable in the super-class. However, in any other case, what does `super();` do? On its own?


When do I use super()?

Consider the following snippet of python code

    class A(object):
        def __init__(self, a):
            self.a = a

    class B(A):
        def __init__(self, a, b):
            super(B, self).__init__(a)
            self.b = b

    class C(A):
        def __init__(self, a, c):
            super(C, self).__init__(a)
            self.c = c

    class D(B, C):
        def __init__(self, a, b, c, d):
            #super(D,self).__init__(a, b, c) ???
            self.d = d

I am wondering how can I pass `a`, `b` and `c` to corresponding base classes&#39; constructors.

python multiple inheritance passing arguments to constructors using super

I understand that `&lt;? super T&gt;` represents any super class of `T` (parent class of `T` of any level). But I really struggle to imagine any real life example for this generic bound wildcard.

I understand what `&lt;? super T&gt;` means and I have seen this method:

    public class Collections {
      public static &lt;T&gt; void copy(List&lt;? super T&gt; dest, List&lt;? extends T&gt; src) {
          for (int i = 0; i &lt; src.size(); i++)
            dest.set(i, src.get(i));
      }
    }

I am looking for an example of *real life use case* where this construction can be used and not for an explanation of what it is.


What is a real life example of generic &lt;? super T&gt;?

Is super() not meant to be used with staticmethods?

When I try something like

    class First(object):
      @staticmethod
      def getlist():
        return [&#39;first&#39;]
    
    class Second(First):
      @staticmethod
      def getlist():
        l = super(Second).getlist()
        l.append(&#39;second&#39;)
        return l
    
    a = Second.getlist()
    print a

I get the following error

    Traceback (most recent call last):
      File &quot;asdf.py&quot;, line 13, in &lt;module&gt;
        a = Second.getlist()
      File &quot;asdf.py&quot;, line 9, in getlist
        l = super(Second).getlist()
    AttributeError: &#39;super&#39; object has no attribute &#39;getlist&#39;

If I change the staticmethods to classmethods and pass the class instance to super(), things work fine. Am I calling super(type) incorrectly here or is there something I&#39;m missing? 


super() and @staticmethod interaction

Why can I use `super` only with wildcards and not with type parameters?

For example, in the `Collection` interface, why is the `toArray` method not written like this

    interface Collection&lt;T&gt;{
        &lt;S super T&gt; S[] toArray(S[] a);
    }


Bounding generics with &#39;super&#39; keyword

I am working with some code that has 3 levels of class inheritance.  From the lowest level derived class, what is the syntax for calling a method 2 levels up the hierarchy, e.g. a super.super call?  The &quot;middle&quot; class does not implement the method I need to call.


How to call super method from grandchild class?

I see everywhere examples that super-class methods should be called by:

    super(SuperClass, instance).method(args)

Is there any disadvantage to doing:

    SuperClass.method(instance, args)


Python super method and calling alternatives

I&#39;m running Python 2.5, so this question may not apply to Python 3. When you make a diamond class hierarchy using multiple inheritance and create an object of the derived-most class, Python does the Right Thing (TM). It calls the constructor for the derived-most class, then its parent classes as listed from left to right, then the grandparent. I&#39;m familiar with Python&#39;s [MRO][1]; that&#39;s not my question. I&#39;m curious how the object returned from super actually manages to communicate to calls of super in the parent classes the correct order. Consider this example code:

    #!/usr/bin/python
    
    class A(object):
    	def __init__(self): print &quot;A init&quot;
    
    class B(A):
    	def __init__(self):
    		print &quot;B init&quot;
    		super(B, self).__init__()
    
    class C(A):
    	def __init__(self):
    		print &quot;C init&quot;
    		super(C, self).__init__()
    
    class D(B, C):
    	def __init__(self):
    		print &quot;D init&quot;
    		super(D, self).__init__()
    
    x = D()

The code does the intuitive thing, it prints:

    D init
    B init
    C init
    A init

However, if you comment out the call to super in B&#39;s init function, neither A nor C&#39;s init function is called. This means B&#39;s call to super is somehow aware of C&#39;s existence in the overall class hierarchy. I know that super returns a proxy object with an overloaded get operator, but how does the object returned by super in D&#39;s init definition communicate the existence of C to the object returned by super in B&#39;s init definition? Is the information that subsequent calls of super use stored on the object itself? If so, why isn&#39;t super instead self.super?

Edit: Jekke quite rightly pointed out that it&#39;s not self.super because super is an attribute of the class, not an instance of the class. Conceptually this makes sense, but in practice super isn&#39;t an attribute of the class either! You can test this in the interpreter by making two classes A and B, where B inherits from A, and calling `dir(B)`. It has no `super` or `__super__` attributes.

  [1]: http://www.python.org/download/releases/2.3/mro/


How does Python&#39;s &quot;super&quot; do the right thing?

I have two classes, `Field` and `Background`. They look a little bit like this:

    class Field( object ):
        def __init__( self, a, b ):
            self.a = a
            self.b = b
            self.field = self.buildField()

        def buildField( self ):
            field = [0,0,0]
            return field
    
    class Background( Field ):
        def __init__( self, a, b, c ):
            super(Background, self).__init__( a, b )
            self.field = self.buildField( c )
      
        def buildField( self, c ):
            field = [c]
            return field

    a, b, c = 0, 1, 2
    background = Background( a, b, c )

This error is pointing to Field&#39;s `buildField()`:

    &quot;TypeError: buildField() takes exactly 2 arguments (1 given).&quot;

I expected Background __init__() to be called first.  To pass &quot;a, b&quot; to Fields __init__(), Field to assign a and b then to assign a list with three 0&#39;s in it to field.  Then for Background&#39;s __init__() to continue, to then call its own buildField() and override self.field with a list containing c.

It seems I don&#39;t fully understand super(), however i was unable to find a solution to my issue after looking at similar inheritance problems on the web and around here.

I expected behavior like c++ where a class can override a method that was inherited.  How can i achieve this or something similar.

Most issues I found related to this were people using double underscores.  My experience with inheritance with super is using the inherited class __init__() to just pass different variables to the super class.  Nothing involving overwriting anything.

Python, Overriding an inherited class method

In Python, how do I pick which Parent&#39;s method to call? Say I want to call the parent ASDF2&#39;s `__init__` method. Seems like I have to specify __ASDF1__ in the super()..? And if I want to call ASDF3&#39;s `__init__`, then I must specify __ASDF2__?!

    &gt;&gt;&gt; class ASDF(ASDF1, ASDF2, ASDF3):
    	def __init__(self):
    		super(ASDF1, self).__init__()
    
    		
    &gt;&gt;&gt; ASDF()
    ASDF2&#39;s __init__ happened
    &gt;&gt;&gt; class ASDF(ASDF1, ASDF2, ASDF3):
    	def __init__(self):
    		super(ASDF2, self).__init__()
    
    		
    &gt;&gt;&gt; ASDF()
    ASDF3&#39;s __init__ happened

Seems bonkers to me. What am I doing wrong?

Python&#39;s Multiple Inheritance: Picking which super() to call

What is the equivalent c# keyword of super keyword (java).

My java code :

    public class PrintImageLocations extends PDFStreamEngine
    {
        public PrintImageLocations() throws IOException
        {
            super( ResourceLoader.loadProperties( &quot;org/apache/pdfbox/resources/PDFTextStripper.properties&quot;, true ) );
        } 

         protected void processOperator( PDFOperator operator, List arguments ) throws IOException
        {
         super.processOperator( operator, arguments );
        }


Now what exactly I need equivalent of super keyword  in C# 
initially tried with `base` whether the way I have used the keyword base in right way 
 

    class Imagedata : PDFStreamEngine
    {
       public Imagedata() : base()
       {                                          
             ResourceLoader.loadProperties(&quot;org/apache/pdfbox/resources/PDFTextStripper.properties&quot;, true);
       }
    
       protected override void processOperator(PDFOperator operations, List arguments)
       {
          base.processOperator(operations, arguments);
       }
    }

Can any one help me out.










Equivalent of Super Keyword in C#

I&#39;ve recently discovered (via StackOverflow) that to call a method in a base class I should call:

`super([[derived class]], self).[[base class method]]()`

That&#39;s fine, it works.  However, I find myself often copying and pasting between classes when I make a change and frequently I forget to fix the derived class argument to the super() function.  

I&#39;d like to avoid having to remember to change the derived class argument.  Can I instead just use `self.__class__` as the first argument of the super() function?

It seems to work but are there good reasons why I shouldn&#39;t do this?

When calling super() in a derived class, can I pass in self.__class__?

As far as I know, it&#39;s a pointer to the superclass. It&#39;s hard-wired with the superclass, and not dynamically figured out at runtime. Would like to know it more in detail...

Anyone?

All Super Solutions on Gang of Coders

Total of 28 Super Solutions

Understanding Python super() with init() methods

What is PECS (Producer Extends Consumer Super)?

What does 'super' do in Python? - difference between super().init() and explicit superclass init()

super() raises "TypeError: must be type, not classobj" for new-style class

Calling parent class init with multiple inheritance, what's the right way?

super() in Java

super() fails with error: TypeError "argument 1 must be type, not classobj" when parent does not inherit from object

Is it unnecessary to put super() in constructor?

Why is Python 3.x's super() magic?

Python super() raises TypeError

Java: Calling a super method which calls an overridden method

super.onCreate(savedInstanceState);

Using super with a class method

Getting the name of a sub-class from within a super-class

How to force derived class to call super method? (Like Android does)

When do I use super()?

python multiple inheritance passing arguments to constructors using super

What is a real life example of generic <? super T>?

super() and @staticmethod interaction

Bounding generics with 'super' keyword

How to call super method from grandchild class?

Python super method and calling alternatives

How does Python's "super" do the right thing?

Python, Overriding an inherited class method

Python's Multiple Inheritance: Picking which super() to call

Equivalent of Super Keyword in C#

When calling super() in a derived class, can I pass in self.class?

What exactly is super in Objective-C?