Second parameter of super()?

Question

A colleague of mine wrote code analogous to the following today, asked me to have a look, and it took me a while to spot the mistake:

class A():                                                                                         
    def __init__(self):                                                         
        print('A')                                                              

class B(A):                                                                     
    def __init__(self):                                                         
        super(B).__init__()                                               

b = B()

The problem here is that there's no self parameter to super() in B's constructor. What surprised me is that absolutely nothing happens in this case, i.e. no error, nothing. What does the super object created by super(B) contain? As an object, it clearly has a constructor, so that's what gets called, but how is that object related to B? In particular, why is this valid code and doesn't throw an exception somewhere? Is super(B) an object with some actual use and what would that be?

The documentation on super states that omitting the second argument causes it to create an unbound object — UnholySheep
– UnholySheep, Commented Jan 17, 2018 at 13:39
What's even more odd is that calling super(B).__init__() only works inside of a method of B (or a subclass of B). Calling super(B).__init__() outside of a class throws RuntimeError: super(): no arguments — Aran-Fey
– Aran-Fey, Commented Jan 17, 2018 at 13:59

Kasravnd · Accepted Answer · 2018-01-19 09:05:39Z

6

The only thing that causes all these ambiguities is that "why obj = super(B).__init__() works?". That's because super(B).__self_class__ returns None and in that case you're calling the None objects' __init__ like following which returns None:

In [40]: None.__init__()

Regarding the rest of the cases, you can simply check the difference by calling the super's essential attributes in both cases:

In [36]: class B(A):                                                                     
        def __init__(self):                                                         
                obj = super(B, self)
                print(obj.__class__)
                print(obj.__thisclass__)
                print(obj.__self_class__)
                print(obj.__self__)
   ....:         

In [37]: b = B()
<class 'super'>
<class '__main__.B'>
<class '__main__.B'>
<__main__.B object at 0x7f15a813f940>

In [38]: 

In [38]: class B(A):                                                                     
        def __init__(self):                                                         
                obj = super(B)
                print(obj.__class__)
                print(obj.__thisclass__)
                print(obj.__self_class__)
                print(obj.__self__)
   ....:         

In [39]: b = B()
<class 'super'>
<class '__main__.B'>
None
None

For the rest of the things I recommend you to read the documentation thoroughly. https://docs.python.org/3/library/functions.html#super and this article by Raymond Hettinger https://rhettinger.wordpress.com/2011/05/26/super-considered-super/.

Moreover, If you want to know why super(B) doesn't work outside of the class and generally why calling the super() without any argument works inside a class you can read This comprehensive answer by Martijn https://stackoverflow.com/a/19609168/2867928.

A short description of the solution:

As mentioned in the comments by @Nathan Vērzemnieks you need to call the initializer once to get the super() object work. The reason is laid behind the magic of new super object that is explained in aforementioned links.

In [1]: class A:
   ...:     def __init__(self):
   ...:         print("finally!")
   ...:

In [2]: class B(A):
   ...:     def __init__(self):
   ...:         sup = super(B)
   ...:         print("Before: {}".format(sup))
   ...:         sup.__init__()
   ...:         print("After: {}".format(sup))
   ...:         sup.__init__()
   ...:

In [3]: B()
Before: <super: <class 'B'>, NULL>
After: <super: <class 'B'>, <B object>>
finally!

edited Jan 19, 2018 at 9:05

answered Jan 17, 2018 at 14:00

Kasravnd

108k19 gold badges167 silver badges196 bronze badges

Sign up to request clarification or add additional context in comments.

9 Comments

Kasravnd Over a year ago

@Rawing Isn't that explained in rhettinger.wordpress.com/2011/05/26/super-considered-super?

Kasravnd Over a year ago

@Rawing That's strongly related to the magic of super() in python 3.X which can be called without arguments inside a class. Here is a question regard this very topic stackoverflow.com/questions/19608134/… that is answered nicely by Martijn.

Aran-Fey Over a year ago

As far as I can tell, that only applies to the 0-argument form of super. Anyway, I'll stop pestering you (sorry about that!) and post a new question about it. Let's clean up this mess, shall we?

Nathan Vērzemnieks Over a year ago

I don't think it's true that super(B).__init__() is calling None.__init__(). See this gist for evidence to the contrary: gist.github.com/njvrzm/358f96c971a2adc329bcc1d860bede2a

Nathan Vērzemnieks Over a year ago

Actually I've copied the code from that gist to my answer to this related question.

|

Nathan Vērzemnieks · Accepted Answer · 2018-01-20 19:00:45Z

The confusion here comes from the fact that (in a class definition context) super() gives a bound super object which then delegates __init__ to its __self_class__, while super(B) creates an unbound super object which, because its __self_class__ is None, does not delegate.

In [41]: class Test(int):
    ...:     def __init__(self):
    ...:         print(super().__self_class__)
    ...:         print(super().__init__)
    ...:         print(super(Test).__self_class__)
    ...:         print(super(Test).__init__)
    ...:

In [42]: Test()
<class '__main__.Test'>
<method-wrapper '__init__' of Test object at 0x10835c9c8>
None
<method-wrapper '__init__' of super object at 0x10835c3c8>

So when you call super(B).__init__(), it creates an unbound super but then immediately calls __init__ on it; that, because of the magic described in the various links in this other answer, binds that unbound super. There are no references to it, so it disappears, but that's what's happening under the hood.

Collectives™ on Stack Overflow

Second parameter of super()?

2 Answers 2

9 Comments

Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

9 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related