What does super do in Python

Question

What 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 ve seen super being used quite a lot in classes with only single inheritance  I can see why you d use it in multiple inheritance but am unclear as to what the advantages are of using it in this kind of situation

User · Answer

class Child SomeBaseClass       def   init   self           SomeBaseClass   init   self    This is fairly easy to understand   class Child SomeBaseClass       def   init   self           super Child  self    init       Ok  what happens now if you use super Child self    When a Child instance is created  its MRO Method Resolution Order  is in the order of  Child  SomeBaseClass  object  based on the inheritance   assume SomeBaseClass doesn t have other parents except for the default object   By passing Child  self   super searches in the MRO of the self instance  and return the proxy object next of Child  in this case it s SomeBaseClass  this object then invokes the   init   method of SomeBaseClass  In other word  if it s super SomeBaseClass self   the proxy object that super returns would be object   For multi inheritance  the MRO could contain many classes  so basically super lets you decide where you want to start searching in the MRO

User · Answer

class Child SomeBaseClass       def   init   self           SomeBaseClass   init   self    This is fairly easy to understand   class Child SomeBaseClass       def   init   self           super Child  self    init       Ok  what happens now if you use super Child self    When a Child instance is created  its MRO Method Resolution Order  is in the order of  Child  SomeBaseClass  object  based on the inheritance   assume SomeBaseClass doesn t have other parents except for the default object   By passing Child  self   super searches in the MRO of the self instance  and return the proxy object next of Child  in this case it s SomeBaseClass  this object then invokes the   init   method of SomeBaseClass  In other word  if it s super SomeBaseClass self   the proxy object that super returns would be object   For multi inheritance  the MRO could contain many classes  so basically super lets you decide where you want to start searching in the MRO

User · Answer

Doesn t all of this assume that the base class is a new-style class   class A      def   init   self           print  A   init        class B A       def   init   self           print  B   init               super B  self    init       Will not work in Python 2  class A must be new-style  i e  class A object

User · Answer

The benefits of super   in single-inheritance are minimal -- mostly  you don t have to hard-code the name of the base class into every method that uses its parent methods   However  it s almost impossible to use multiple-inheritance without super    This includes common idioms like mixins  interfaces  abstract classes  etc  This extends to code that later extends yours  If somebody later wanted to write a class that extended Child and a mixin  their code would not work properly

User · Answer

In the case of multiple inheritance  you normally want to call the initializers of both parents  not just the first  Instead of always using the base class  super   finds the class that is next in Method Resolution Order  MRO   and returns the current object as an instance of that class  For example  class Base object       def   init   self           print  quot initializing Base quot    class ChildA Base       def   init   self           print  quot initializing ChildA quot           Base   init   self   class ChildB Base       def   init   self           print  quot initializing ChildB quot           super     init      class Grandchild ChildA  ChildB       def   init   self           print  quot initializing Grandchild quot           super     init              Grandchild    results in initializing Grandchild initializing ChildA initializing Base  Replacing Base   init   self  with super     init     results in initializing Grandchild initializing ChildA initializing ChildB initializing Base  as desired

User · Answer

Many great answers  but for visual learners  Firstly lets explore with arguments to super  and then without    Imagine theres an instance jack created from the class Jack  who has the inheritance chain as shown in green in the picture  Calling   super Jack  jack  method        will use the MRO  Method Resolution Order  of jack  its inheritance tree in a certain order   and will start searching from Jack  Why can one provide a parent class  Well if we start searching from the instance jack  it would find the instance method  the whole point is to find its parents method   If one does not supply arguments to super  its like the first argument passed in is the class of self  and the second argument passed in is self  These are auto-calculated for you in Python3   However say we dont want to use Jack s method  instead of passing in Jack  we could of passed in Jen to start searching upwards for the method from Jen   It searches one layer at a time  width not depth   e g  if Adam and Sue both have the required method  the one from Sue will be found first   If Cain and Sue both had the required method  Cain s method would be called first  This corresponds in code to   Class Jen Cain  Sue     MRO is from left to right

User · Answer

Super   in a nutshell  Every Python instance has a class that created it  Every class in Python has a chain of ancestor classes  A method using super   delegates work to the next ancestor in the chain for the instance s class   Example This small example covers all the interesting cases  class A      def m self           print  A    class B A       def m self           print  B start           super   m           print  B end            class C A       def m self           print  C start           super   m           print  C end    class D B  C       def m self           print  D start           super   m           print  D end    The exact order of calls in determined by the instance the method is called from   gt  gt  gt  a   A    gt  gt  gt  b   B    gt  gt  gt  c   C    gt  gt  gt  d   D    For instance a  there is no super call   gt  gt  gt  a m   A  For instance b  the ancestor chain is B - gt  A - gt  object   gt  gt  gt  type b    mro        lt class    main   B  gt    lt class    main   A  gt    lt class  object  gt     gt  gt  gt  b m   B start A B end  For instance c  the ancestor chain is C - gt  A - gt  object   gt  gt  gt  type c    mro        lt class    main   C  gt    lt class    main   A  gt    lt class  object  gt     gt  gt  gt  b m   C start A C end  For instance d  the ancestor chain is more interesting D - gt  B - gt  C - gt  A - gt  object   gt  gt  gt  type d    mro     lt class    main   D  gt    lt class    main   B  gt    lt class    main   C  gt    lt class    main   A  gt    lt class  object  gt     gt  gt  gt  d m   D start B start C start A C end B end D end  More information Having answered the question of  quot What does super do in Python  quot   the next question is how to use it effectively   See this step-by-step tutorial or this 45 minute video

User · Answer

What s the difference   SomeBaseClass   init   self     means to call SomeBaseClass s   init    while  super Child  self    init       means to call a bound   init   from the parent class that follows Child in the instance s Method Resolution Order  MRO     If the instance is a subclass of Child  there may be a different parent that comes next in the MRO    Explained simply  When you write a class  you want other classes to be able to use it  super   makes it easier for other classes to use the class you re writing   As Bob Martin says  a good architecture allows you to postpone decision making as long as possible   super   can enable that sort of architecture   When another class subclasses the class you wrote  it could also be inheriting from other classes  And those classes could have an   init   that comes after this   init   based on the ordering of the classes for method resolution   Without super you would likely hard-code the parent of the class you re writing  like the example does   This would mean that you would not call the next   init   in the MRO  and you would thus not get to reuse the code in it   If you re writing your own code for personal use  you may not care about this distinction  But if you want others to use your code  using super is one thing that allows greater flexibility for users of the code   Python 2 versus 3  This works in Python 2 and 3   super Child  self    init       This only works in Python 3   super     init       It works with no arguments by moving up in the stack frame and getting the first argument to the method  usually self for an instance method or cls for a class method - but could be other names  and finding the class  e g  Child  in the free variables  it is looked up with the name   class   as a free closure variable in the method    I prefer to demonstrate the cross-compatible way of using super  but if you are only using Python 3  you can call it with no arguments   Indirection with Forward Compatibility  What does it give you  For single inheritance  the examples from the question are practically identical from a static analysis point of view  However  using super gives you a layer of indirection with forward compatibility   Forward compatibility is very important to seasoned developers  You want your code to keep working with minimal changes as you change it  When you look at your revision history  you want to see precisely what changed when    You may start off with single inheritance  but if you decide to add another base class  you only have to change the line with the bases - if the bases change in a class you inherit from  say a mixin is added  you d change nothing in this class  Particularly in Python 2  getting the arguments to super and the correct method arguments right can be difficult  If you know you re using super correctly with single inheritance  that makes debugging less difficult going forward   Dependency Injection  Other people can use your code and inject parents into the method resolution   class SomeBaseClass object       def   init   self           print  SomeBaseClass   init   self  called    class UnsuperChild SomeBaseClass       def   init   self           print  UnsuperChild   init   self  called           SomeBaseClass   init   self   class SuperChild SomeBaseClass       def   init   self           print  SuperChild   init   self  called           super SuperChild  self    init       Say you add another class to your object  and want to inject a class between Foo and Bar  for testing or some other reason    class InjectMe SomeBaseClass       def   init   self           print  InjectMe   init   self  called           super InjectMe  self    init      class UnsuperInjector UnsuperChild  InjectMe   pass  class SuperInjector SuperChild  InjectMe   pass   Using the un-super child fails to inject the dependency because the child you re using has hard-coded the method to be called after its own    gt  gt  gt  o   UnsuperInjector   UnsuperChild   init   self  called SomeBaseClass   init   self  called   However  the class with the child that uses super can correctly inject the dependency    gt  gt  gt  o2   SuperInjector   SuperChild   init   self  called InjectMe   init   self  called SomeBaseClass   init   self  called   Addressing a comment     Why in the world would this be useful     Python linearizes a complicated inheritance tree via the C3 linearization algorithm to create a Method Resolution Order  MRO    We want methods to be looked up in that order   For a method defined in a parent to find the next one in that order without super  it would have to    get the mro from the instance s type  look for the type that defines the method find the next type with the method bind that method and call it with the expected arguments      The UnsuperChild should not have access to InjectMe  Why isn t the conclusion  Always avoid using super   What am I missing here    The UnsuperChild does not have access to InjectMe  It is the UnsuperInjector that has access to InjectMe - and yet cannot call that class s method from the method it inherits from UnsuperChild    Both Child classes intend to call a method by the same name that comes next in the MRO  which might be another class it was not aware of when it was created    The one without super hard-codes its parent s method - thus is has restricted the behavior of its method  and subclasses cannot inject functionality in the call chain   The one with super has greater flexibility  The call chain for the methods can be intercepted and functionality injected   You may not need that functionality  but subclassers of your code may   Conclusion  Always use super to reference the parent class instead of hard-coding it   What you intend is to reference the parent class that is next-in-line  not specifically the one you see the child inheriting from   Not using super can put unnecessary constraints on users of your code

User · Answer

Doesn t all of this assume that the base class is a new-style class   class A      def   init   self           print  A   init        class B A       def   init   self           print  B   init               super B  self    init       Will not work in Python 2  class A must be new-style  i e  class A object

User · Answer

some great answers here  but they do not tackle how to use super   in the case where different classes in the hierarchy have different signatures     especially in the case of   init     to answer that part and to be able to effectively use super   i d suggest reading my answer super   and changing the signature of cooperative methods    here s just the solution to this scenario         the top-level classes in your hierarchy must inherit from a custom class like SuperObject    if classes can take differing arguments  always pass all arguments you received on to the super function as keyword arguments  and  always accept   kwargs       class SuperObject              def   init   self    kwargs           print  SuperObject           mro   type self    mro           assert mro -1  is object         if mro -2  is not SuperObject              raise TypeError                   all top-level classes in this hierarchy must inherit from SuperObject                    the last class in the MRO should be SuperObject                   f mro   cls   name   for cls in mro                             super     init   is guaranteed to be object   init                   init   super     init           init     example usage   class A SuperObject       def   init   self    kwargs           print  A           super A  self    init     kwargs   class B SuperObject       def   init   self    kwargs           print  B           super B  self    init     kwargs   class C A       def   init   self  age    kwargs           print  C  f age  age            super C  self    init   age age    kwargs   class D B       def   init   self  name    kwargs           print  D   f name  name            super D  self    init   name name    kwargs   class E C D       def   init   self  name  age   args    kwargs           print   E   f name  name    f age  age            super E  self    init   name name  age age   args    kwargs   E name  python   age 28    output   E name python age 28 C age 28 A D name python B SuperObject

User · Answer

Super   in a nutshell  Every Python instance has a class that created it  Every class in Python has a chain of ancestor classes  A method using super   delegates work to the next ancestor in the chain for the instance s class   Example This small example covers all the interesting cases  class A      def m self           print  A    class B A       def m self           print  B start           super   m           print  B end            class C A       def m self           print  C start           super   m           print  C end    class D B  C       def m self           print  D start           super   m           print  D end    The exact order of calls in determined by the instance the method is called from   gt  gt  gt  a   A    gt  gt  gt  b   B    gt  gt  gt  c   C    gt  gt  gt  d   D    For instance a  there is no super call   gt  gt  gt  a m   A  For instance b  the ancestor chain is B - gt  A - gt  object   gt  gt  gt  type b    mro        lt class    main   B  gt    lt class    main   A  gt    lt class  object  gt     gt  gt  gt  b m   B start A B end  For instance c  the ancestor chain is C - gt  A - gt  object   gt  gt  gt  type c    mro        lt class    main   C  gt    lt class    main   A  gt    lt class  object  gt     gt  gt  gt  b m   C start A C end  For instance d  the ancestor chain is more interesting D - gt  B - gt  C - gt  A - gt  object   gt  gt  gt  type d    mro     lt class    main   D  gt    lt class    main   B  gt    lt class    main   C  gt    lt class    main   A  gt    lt class  object  gt     gt  gt  gt  d m   D start B start C start A C end B end D end  More information Having answered the question of  quot What does super do in Python  quot   the next question is how to use it effectively   See this step-by-step tutorial or this 45 minute video

User · Answer

In the case of multiple inheritance  you normally want to call the initializers of both parents  not just the first  Instead of always using the base class  super   finds the class that is next in Method Resolution Order  MRO   and returns the current object as an instance of that class  For example  class Base object       def   init   self           print  quot initializing Base quot    class ChildA Base       def   init   self           print  quot initializing ChildA quot           Base   init   self   class ChildB Base       def   init   self           print  quot initializing ChildB quot           super     init      class Grandchild ChildA  ChildB       def   init   self           print  quot initializing Grandchild quot           super     init              Grandchild    results in initializing Grandchild initializing ChildA initializing Base  Replacing Base   init   self  with super     init     results in initializing Grandchild initializing ChildA initializing ChildB initializing Base  as desired

User · Answer

Doesn t all of this assume that the base class is a new-style class   class A      def   init   self           print  A   init        class B A       def   init   self           print  B   init               super B  self    init       Will not work in Python 2  class A must be new-style  i e  class A object

User · Answer

some great answers here  but they do not tackle how to use super   in the case where different classes in the hierarchy have different signatures     especially in the case of   init     to answer that part and to be able to effectively use super   i d suggest reading my answer super   and changing the signature of cooperative methods    here s just the solution to this scenario         the top-level classes in your hierarchy must inherit from a custom class like SuperObject    if classes can take differing arguments  always pass all arguments you received on to the super function as keyword arguments  and  always accept   kwargs       class SuperObject              def   init   self    kwargs           print  SuperObject           mro   type self    mro           assert mro -1  is object         if mro -2  is not SuperObject              raise TypeError                   all top-level classes in this hierarchy must inherit from SuperObject                    the last class in the MRO should be SuperObject                   f mro   cls   name   for cls in mro                             super     init   is guaranteed to be object   init                   init   super     init           init     example usage   class A SuperObject       def   init   self    kwargs           print  A           super A  self    init     kwargs   class B SuperObject       def   init   self    kwargs           print  B           super B  self    init     kwargs   class C A       def   init   self  age    kwargs           print  C  f age  age            super C  self    init   age age    kwargs   class D B       def   init   self  name    kwargs           print  D   f name  name            super D  self    init   name name    kwargs   class E C D       def   init   self  name  age   args    kwargs           print   E   f name  name    f age  age            super E  self    init   name name  age age   args    kwargs   E name  python   age 28    output   E name python age 28 C age 28 A D name python B SuperObject

User · Answer

Consider the following code   class X        def   init   self           print  X    class Y X       def   init   self             X   init   self          super Y  self    init             print  Y    class P X       def   init   self           super P  self    init             print  P    class Q Y  P       def   init   self           super Q  self    init             print  Q    Q     If change constructor of Y to X   init    you will get   X Y Q   But using super Y  self    init      you will get   X P Y Q   And P or Q may even be involved from another file which you don t know when you writing X and Y  So  basically  you won t know what super Child  self  will reference to when you are writing class Y X   even the signature of Y is as simple as Y X   That s why super could be a better choice

User · Answer

What s the difference   SomeBaseClass   init   self     means to call SomeBaseClass s   init    while  super Child  self    init       means to call a bound   init   from the parent class that follows Child in the instance s Method Resolution Order  MRO     If the instance is a subclass of Child  there may be a different parent that comes next in the MRO    Explained simply  When you write a class  you want other classes to be able to use it  super   makes it easier for other classes to use the class you re writing   As Bob Martin says  a good architecture allows you to postpone decision making as long as possible   super   can enable that sort of architecture   When another class subclasses the class you wrote  it could also be inheriting from other classes  And those classes could have an   init   that comes after this   init   based on the ordering of the classes for method resolution   Without super you would likely hard-code the parent of the class you re writing  like the example does   This would mean that you would not call the next   init   in the MRO  and you would thus not get to reuse the code in it   If you re writing your own code for personal use  you may not care about this distinction  But if you want others to use your code  using super is one thing that allows greater flexibility for users of the code   Python 2 versus 3  This works in Python 2 and 3   super Child  self    init       This only works in Python 3   super     init       It works with no arguments by moving up in the stack frame and getting the first argument to the method  usually self for an instance method or cls for a class method - but could be other names  and finding the class  e g  Child  in the free variables  it is looked up with the name   class   as a free closure variable in the method    I prefer to demonstrate the cross-compatible way of using super  but if you are only using Python 3  you can call it with no arguments   Indirection with Forward Compatibility  What does it give you  For single inheritance  the examples from the question are practically identical from a static analysis point of view  However  using super gives you a layer of indirection with forward compatibility   Forward compatibility is very important to seasoned developers  You want your code to keep working with minimal changes as you change it  When you look at your revision history  you want to see precisely what changed when    You may start off with single inheritance  but if you decide to add another base class  you only have to change the line with the bases - if the bases change in a class you inherit from  say a mixin is added  you d change nothing in this class  Particularly in Python 2  getting the arguments to super and the correct method arguments right can be difficult  If you know you re using super correctly with single inheritance  that makes debugging less difficult going forward   Dependency Injection  Other people can use your code and inject parents into the method resolution   class SomeBaseClass object       def   init   self           print  SomeBaseClass   init   self  called    class UnsuperChild SomeBaseClass       def   init   self           print  UnsuperChild   init   self  called           SomeBaseClass   init   self   class SuperChild SomeBaseClass       def   init   self           print  SuperChild   init   self  called           super SuperChild  self    init       Say you add another class to your object  and want to inject a class between Foo and Bar  for testing or some other reason    class InjectMe SomeBaseClass       def   init   self           print  InjectMe   init   self  called           super InjectMe  self    init      class UnsuperInjector UnsuperChild  InjectMe   pass  class SuperInjector SuperChild  InjectMe   pass   Using the un-super child fails to inject the dependency because the child you re using has hard-coded the method to be called after its own    gt  gt  gt  o   UnsuperInjector   UnsuperChild   init   self  called SomeBaseClass   init   self  called   However  the class with the child that uses super can correctly inject the dependency    gt  gt  gt  o2   SuperInjector   SuperChild   init   self  called InjectMe   init   self  called SomeBaseClass   init   self  called   Addressing a comment     Why in the world would this be useful     Python linearizes a complicated inheritance tree via the C3 linearization algorithm to create a Method Resolution Order  MRO    We want methods to be looked up in that order   For a method defined in a parent to find the next one in that order without super  it would have to    get the mro from the instance s type  look for the type that defines the method find the next type with the method bind that method and call it with the expected arguments      The UnsuperChild should not have access to InjectMe  Why isn t the conclusion  Always avoid using super   What am I missing here    The UnsuperChild does not have access to InjectMe  It is the UnsuperInjector that has access to InjectMe - and yet cannot call that class s method from the method it inherits from UnsuperChild    Both Child classes intend to call a method by the same name that comes next in the MRO  which might be another class it was not aware of when it was created    The one without super hard-codes its parent s method - thus is has restricted the behavior of its method  and subclasses cannot inject functionality in the call chain   The one with super has greater flexibility  The call chain for the methods can be intercepted and functionality injected   You may not need that functionality  but subclassers of your code may   Conclusion  Always use super to reference the parent class instead of hard-coding it   What you intend is to reference the parent class that is next-in-line  not specifically the one you see the child inheriting from   Not using super can put unnecessary constraints on users of your code

User · Answer

I had played a bit with super    and had recognized that we can change calling order   For example  we have next hierarchy structure       A          B   C            D   In this case MRO of D will be  only for Python 3    In  26   D   mro   Out 26      main   D    main   B    main   C    main   A  object    Let s create a class where super   calls after method execution   In  23   class A object      or with Python 3 can define class A           def   init   self                print  I m from A               class B A             def   init   self                 print  I m from B                 super     init                  class C A             def   init   self                 print  I m from C                 super     init                 class D B  C             def   init   self                 print  I m from D                 super     init          d   D        I m from D I m from B I m from C I m from A      A          B   C            D   So we can see that resolution order is same as in MRO  But when we call super   in the beginning of the method   In  21   class A object      or class A           def   init   self                print  I m from A               class B A             def   init   self                 super     init        or super B  self    init                  print  I m from B                class C A             def   init   self                 super     init                   print  I m from C               class D B  C             def   init   self                 super     init                   print  I m from D        d   D         I m from A I m from C I m from B I m from D   We have a different order it is reversed a order of the MRO tuple       A          B   C            D    For additional reading I would recommend next answers    C3 linearization example with super  a large hierarchy  Important behavior changes between old and new style classes The Inside Story on New-Style Classes

User · Answer

The benefits of super   in single-inheritance are minimal -- mostly  you don t have to hard-code the name of the base class into every method that uses its parent methods   However  it s almost impossible to use multiple-inheritance without super    This includes common idioms like mixins  interfaces  abstract classes  etc  This extends to code that later extends yours  If somebody later wanted to write a class that extended Child and a mixin  their code would not work properly

User · Answer

When calling super   to resolve to a parent s version of a classmethod  instance method  or staticmethod  we want to pass the current class whose scope we are in as the first argument  to indicate which parent s scope we re trying to resolve to  and as a second argument the object of interest to indicate which object we re trying to apply that scope to   Consider a class hierarchy A  B  and C where each class is the parent of the one following it  and a  b  and c respective instances of each   super B  b     resolves to the scope of B s parent i e  A    and applies that scope to b  as if b was an instance of A  super C  c     resolves to the scope of C s parent i e  B   and applies that scope to c  super B  c     resolves to the scope of B s parent i e  A    and applies that scope to c   Using super with a staticmethod  e g  using super   from within the   new     method  class A object       def   new   cls   a    kw                           whatever you want to specialize or override here                        return super A  cls    new   cls   a    kw    Explanation    1- even though it s usual for   new     to take as its first param a reference to the calling class  it is not implemented in Python as a classmethod  but rather a staticmethod  That is  a reference to a class has to be passed explicitly as the first argument when calling   new     directly     if you defined this class A object       def   new   cls           pass    calling this would raise a TypeError due to the missing argument A   new        whereas this would be fine A   new   A    2- when calling super   to get to the parent class we pass the child class A as its first argument  then we pass a reference to the object of interest  in this case it s the class reference that was passed when A   new   cls  was called  In most cases it also happens to be a reference to the child class  In some situations it might not be  for instance in the case of multiple generation inheritances   super A  cls    3- since as a general rule   new     is a staticmethod  super A  cls    new   will also return a staticmethod and needs to be supplied all arguments explicitly  including the reference to the object of insterest  in this case cls   super A  cls    new   cls   a    kw    4- doing the same thing without super  class A object       def   new   cls   a    kw                           whatever you want to specialize or override here                        return object   new   cls   a    kw    Using super with an instance method  e g  using super   from within   init      class A object        def   init   self   a    kw                           you make some changes here                        super A  self    init    a    kw    Explanation   1-   init   is an instance method  meaning that it takes as its first argument a reference to an instance  When called directly from the instance  the reference is passed implicitly  that is you don t need to specify it     you try calling    init      from the class without specifying an instance   and a TypeError is raised due to the expected but missing reference A   init       TypeError        you create an instance a   A      you call    init      from that instance and it works a   init        you can also call    init      with the class and explicitly pass the instance  A   init   a    2- when calling super   within   init     we pass the child class as the first argument and the object of interest as a second argument  which in general is a reference to an instance of the child class   super A  self    3- The call super A  self  returns a proxy that will resolve the scope and apply it to self as if it s now an instance of the parent class  Let s call that proxy s  Since   init     is an instance method the call s   init        will implicitly pass a reference of self as the first argument to the parent s   init       4- to do the same without super we need to pass a reference to an instance explicitly to the parent s version of   init       class A object        def   init   self   a    kw                           you make some changes here                        object   init   self   a    kw    Using super with a classmethod  class A object        classmethod     def alternate constructor cls   a    kw           print  A alternate constructor called          return cls  a    kw   class B A        classmethod     def alternate constructor cls   a    kw                           whatever you want to specialize or override here                        print  B alternate constructor called          return super B  cls  alternate constructor  a    kw    Explanation   1- A classmethod can be called from the class directly and takes as its first parameter a reference to the class      calling directly from the class is fine    a reference to the class is passed implicitly a   A alternate constructor   b   B alternate constructor     2- when calling super   within a classmethod to resolve to its parent s version of it  we want to pass the current child class as the first argument to indicate which parent s scope we re trying to resolve to  and the object of interest as the second argument to indicate which object we want to apply that scope to  which in general is a reference to the child class itself or one of its subclasses   super B  cls or subcls    3- The call super B  cls  resolves to the scope of A and applies it to cls  Since alternate constructor   is a classmethod the call super B  cls  alternate constructor      will implicitly pass a reference of cls as the first argument to A s version of alternate constructor    super B  cls  alternate constructor     4- to do the same without using super   you would need to get a reference to the unbound version of A alternate constructor    i e  the explicit version of the function   Simply doing this would not work   class B A        classmethod     def alternate constructor cls   a    kw                           whatever you want to specialize or override here                        print  B alternate constructor called          return A alternate constructor cls   a    kw    The above would not work because the A alternate constructor   method takes an implicit reference to A as its first argument  The cls being passed here would be its second argument   class B A        classmethod     def alternate constructor cls   a    kw                           whatever you want to specialize or override here                        print  B alternate constructor called            first we get a reference to the unbound             A alternate constructor  function          unbound func   A alternate constructor im func           now we call it and pass our own  cls  as its first argument         return unbound func cls   a    kw

User · Answer

Many great answers  but for visual learners  Firstly lets explore with arguments to super  and then without    Imagine theres an instance jack created from the class Jack  who has the inheritance chain as shown in green in the picture  Calling   super Jack  jack  method        will use the MRO  Method Resolution Order  of jack  its inheritance tree in a certain order   and will start searching from Jack  Why can one provide a parent class  Well if we start searching from the instance jack  it would find the instance method  the whole point is to find its parents method   If one does not supply arguments to super  its like the first argument passed in is the class of self  and the second argument passed in is self  These are auto-calculated for you in Python3   However say we dont want to use Jack s method  instead of passing in Jack  we could of passed in Jen to start searching upwards for the method from Jen   It searches one layer at a time  width not depth   e g  if Adam and Sue both have the required method  the one from Sue will be found first   If Cain and Sue both had the required method  Cain s method would be called first  This corresponds in code to   Class Jen Cain  Sue     MRO is from left to right

User · Answer

I had played a bit with super    and had recognized that we can change calling order   For example  we have next hierarchy structure       A          B   C            D   In this case MRO of D will be  only for Python 3    In  26   D   mro   Out 26      main   D    main   B    main   C    main   A  object    Let s create a class where super   calls after method execution   In  23   class A object      or with Python 3 can define class A           def   init   self                print  I m from A               class B A             def   init   self                 print  I m from B                 super     init                  class C A             def   init   self                 print  I m from C                 super     init                 class D B  C             def   init   self                 print  I m from D                 super     init          d   D        I m from D I m from B I m from C I m from A      A          B   C            D   So we can see that resolution order is same as in MRO  But when we call super   in the beginning of the method   In  21   class A object      or class A           def   init   self                print  I m from A               class B A             def   init   self                 super     init        or super B  self    init                  print  I m from B                class C A             def   init   self                 super     init                   print  I m from C               class D B  C             def   init   self                 super     init                   print  I m from D        d   D         I m from A I m from C I m from B I m from D   We have a different order it is reversed a order of the MRO tuple       A          B   C            D    For additional reading I would recommend next answers    C3 linearization example with super  a large hierarchy  Important behavior changes between old and new style classes The Inside Story on New-Style Classes

User · Answer

When calling super   to resolve to a parent s version of a classmethod  instance method  or staticmethod  we want to pass the current class whose scope we are in as the first argument  to indicate which parent s scope we re trying to resolve to  and as a second argument the object of interest to indicate which object we re trying to apply that scope to   Consider a class hierarchy A  B  and C where each class is the parent of the one following it  and a  b  and c respective instances of each   super B  b     resolves to the scope of B s parent i e  A    and applies that scope to b  as if b was an instance of A  super C  c     resolves to the scope of C s parent i e  B   and applies that scope to c  super B  c     resolves to the scope of B s parent i e  A    and applies that scope to c   Using super with a staticmethod  e g  using super   from within the   new     method  class A object       def   new   cls   a    kw                           whatever you want to specialize or override here                        return super A  cls    new   cls   a    kw    Explanation    1- even though it s usual for   new     to take as its first param a reference to the calling class  it is not implemented in Python as a classmethod  but rather a staticmethod  That is  a reference to a class has to be passed explicitly as the first argument when calling   new     directly     if you defined this class A object       def   new   cls           pass    calling this would raise a TypeError due to the missing argument A   new        whereas this would be fine A   new   A    2- when calling super   to get to the parent class we pass the child class A as its first argument  then we pass a reference to the object of interest  in this case it s the class reference that was passed when A   new   cls  was called  In most cases it also happens to be a reference to the child class  In some situations it might not be  for instance in the case of multiple generation inheritances   super A  cls    3- since as a general rule   new     is a staticmethod  super A  cls    new   will also return a staticmethod and needs to be supplied all arguments explicitly  including the reference to the object of insterest  in this case cls   super A  cls    new   cls   a    kw    4- doing the same thing without super  class A object       def   new   cls   a    kw                           whatever you want to specialize or override here                        return object   new   cls   a    kw    Using super with an instance method  e g  using super   from within   init      class A object        def   init   self   a    kw                           you make some changes here                        super A  self    init    a    kw    Explanation   1-   init   is an instance method  meaning that it takes as its first argument a reference to an instance  When called directly from the instance  the reference is passed implicitly  that is you don t need to specify it     you try calling    init      from the class without specifying an instance   and a TypeError is raised due to the expected but missing reference A   init       TypeError        you create an instance a   A      you call    init      from that instance and it works a   init        you can also call    init      with the class and explicitly pass the instance  A   init   a    2- when calling super   within   init     we pass the child class as the first argument and the object of interest as a second argument  which in general is a reference to an instance of the child class   super A  self    3- The call super A  self  returns a proxy that will resolve the scope and apply it to self as if it s now an instance of the parent class  Let s call that proxy s  Since   init     is an instance method the call s   init        will implicitly pass a reference of self as the first argument to the parent s   init       4- to do the same without super we need to pass a reference to an instance explicitly to the parent s version of   init       class A object        def   init   self   a    kw                           you make some changes here                        object   init   self   a    kw    Using super with a classmethod  class A object        classmethod     def alternate constructor cls   a    kw           print  A alternate constructor called          return cls  a    kw   class B A        classmethod     def alternate constructor cls   a    kw                           whatever you want to specialize or override here                        print  B alternate constructor called          return super B  cls  alternate constructor  a    kw    Explanation   1- A classmethod can be called from the class directly and takes as its first parameter a reference to the class      calling directly from the class is fine    a reference to the class is passed implicitly a   A alternate constructor   b   B alternate constructor     2- when calling super   within a classmethod to resolve to its parent s version of it  we want to pass the current child class as the first argument to indicate which parent s scope we re trying to resolve to  and the object of interest as the second argument to indicate which object we want to apply that scope to  which in general is a reference to the child class itself or one of its subclasses   super B  cls or subcls    3- The call super B  cls  resolves to the scope of A and applies it to cls  Since alternate constructor   is a classmethod the call super B  cls  alternate constructor      will implicitly pass a reference of cls as the first argument to A s version of alternate constructor    super B  cls  alternate constructor     4- to do the same without using super   you would need to get a reference to the unbound version of A alternate constructor    i e  the explicit version of the function   Simply doing this would not work   class B A        classmethod     def alternate constructor cls   a    kw                           whatever you want to specialize or override here                        print  B alternate constructor called          return A alternate constructor cls   a    kw    The above would not work because the A alternate constructor   method takes an implicit reference to A as its first argument  The cls being passed here would be its second argument   class B A        classmethod     def alternate constructor cls   a    kw                           whatever you want to specialize or override here                        print  B alternate constructor called            first we get a reference to the unbound             A alternate constructor  function          unbound func   A alternate constructor im func           now we call it and pass our own  cls  as its first argument         return unbound func cls   a    kw

User · Answer

The benefits of super   in single-inheritance are minimal -- mostly  you don t have to hard-code the name of the base class into every method that uses its parent methods   However  it s almost impossible to use multiple-inheritance without super    This includes common idioms like mixins  interfaces  abstract classes  etc  This extends to code that later extends yours  If somebody later wanted to write a class that extended Child and a mixin  their code would not work properly

User · Answer

Consider the following code   class X        def   init   self           print  X    class Y X       def   init   self             X   init   self          super Y  self    init             print  Y    class P X       def   init   self           super P  self    init             print  P    class Q Y  P       def   init   self           super Q  self    init             print  Q    Q     If change constructor of Y to X   init    you will get   X Y Q   But using super Y  self    init      you will get   X P Y Q   And P or Q may even be involved from another file which you don t know when you writing X and Y  So  basically  you won t know what super Child  self  will reference to when you are writing class Y X   even the signature of Y is as simple as Y X   That s why super could be a better choice

User · Answer

Doesn t all of this assume that the base class is a new-style class   class A      def   init   self           print  A   init        class B A       def   init   self           print  B   init               super B  self    init       Will not work in Python 2  class A must be new-style  i e  class A object

User · Answer

The benefits of super   in single-inheritance are minimal -- mostly  you don t have to hard-code the name of the base class into every method that uses its parent methods   However  it s almost impossible to use multiple-inheritance without super    This includes common idioms like mixins  interfaces  abstract classes  etc  This extends to code that later extends yours  If somebody later wanted to write a class that extended Child and a mixin  their code would not work properly

[python] What does 'super' do in Python?

Examples related to python

Examples related to oop

Examples related to inheritance

Examples related to multiple-inheritance

Examples related to super