Python extending with - using super Python 3 vs Python 2

Question

Originally I wanted to ask this question  but then I found it was already thought of before    Googling around I found this example of extending configparser  The following works with Python 3    python3 Python 3 2 3rc2  default  Mar 21 2012  06 59 51    GCC 4 6 3  on linux2  gt  gt  gt  from configparser import  SafeConfigParser  gt  gt  gt  class AmritaConfigParser SafeConfigParser           def   init   self               super     init           gt  gt  gt  cfg   AmritaConfigParser    But not with Python 2   gt  gt  gt  class AmritaConfigParser SafeConfigParser             def   init   self                 super SafeConfigParser  init         gt  gt  gt  cfg   AmritaConfigParser   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   init   TypeError  must be type  not classob  Then I read a little bit on Python New Class vs  Old Class styles  e g  here  And now I am wondering  I can do  class MyConfigParser ConfigParser ConfigParser         def Write self  fp              quot  quot  quot override the module s original write funcition quot  quot  quot                       def MyWrite self  fp              quot  quot  quot Define new function and inherit all others quot  quot  quot   But  shouldn t I call init  Is this in Python 2 the equivalent   class AmritaConfigParser ConfigParser SafeConfigParser        def   init   self            super     init       Python3 syntax  or rather  new style class syntax                 is this the equivalent of the above        def   init   self           ConfigParser SafeConfigParser   init   self

User · Answer

Just to have a simple and complete example for Python 3, which most people seem to be using now.

class MySuper(object):
    def __init__(self,a):
        self.a = a

class MySub(MySuper):
    def __init__(self,a,b):
        self.b = b
        super().__init__(a)

my_sub = MySub(42,'chickenman')
print(my_sub.a)
print(my_sub.b)

gives

42
chickenman

User · Answer

super    without arguments  was introduced in Python 3  along with   class      super   - gt  same as super   class    self    so that would be the Python 2 equivalent for new-style classes   super CurrentClass  self   for old-style classes you can always use    class Classname OldStyleParent       def   init   self   args    kwargs           OldStyleParent   init   self   args    kwargs

User · Answer

In a single inheritance case  when you subclass one class only   your new class inherits methods of the base class  This includes   init    So if you don t define it in your class  you will get the one from the base   Things start being complicated if you introduce multiple inheritance  subclassing more than one class at a time   This is because if more than one base class has   init    your class will inherit the first one only   In such cases  you should really use super if you can  I ll explain why  But not always you can  The problem is that all your base classes must also use it  and their base classes as well -- the whole tree    If that is the case  then this will also work correctly  in Python 3 but you could rework it into Python 2 -- it also has super    class A      def   init   self           print  A           super     init      class B      def   init   self           print  B           super     init      class C A  B       pass  C    prints   A  B   Notice how both base classes use super even though they don t have their own base classes   What super does is  it calls the method from the next class in MRO  method resolution order   The MRO for C is   C  A  B  object   You can print C   mro   to see it   So  C inherits   init   from A and super in A   init   calls B   init    B follows A in MRO    So by doing nothing in C  you end up calling both  which is what you want   Now if you were not using super  you would end up inheriting A   init    as before  but this time there s nothing that would call B   init   for you   class A      def   init   self           print  A    class B      def   init   self           print  B    class C A  B       pass  C    prints   A   To fix that you have to define C   init     class C A  B       def   init   self           A   init   self          B   init   self    The problem with that is that in more complicated MI trees    init   methods of some classes may end up being called more than once whereas super MRO guarantee that they re called just once

User · Answer

Another python3 implementation that involves the use of Abstract classes with super    You should remember that     super     init   name  10    has the same effect as    Person   init   self  name  10    Remember there s a hidden  self  in super    So the same object passes on to the superclass init method and the attributes are added to the object that called it   Hence super  gets translated to  Person and then if you include the hidden self  you get the above code frag     from abc import ABCMeta  abstractmethod class Person metaclass ABCMeta       name          age   0      def   init   self  personName  personAge           self name   personName         self age   personAge       abstractmethod     def showName self           pass       abstractmethod     def showAge self           pass   class Man Person        def   init   self  name  height           self height   height           Person   init   self  name  10          super     init   name  10     same as Person   init   self  name  10            basically used to call the superclass init   This is used incase you want to call subclass init           and then also call superclass s init            Since there s a hidden self in the super s parameters  when it s is called            the superclasses attributes are a part of the same object that was sent out in the super   method      def showIdentity self           return self name  self age  self height      def showName self           pass      def showAge self           pass   a   Man  piyush    179   print a showIdentity

User · Answer

In short  they are equivalent   Let s have a history view    1  at first  the function looks like this       class MySubClass MySuperClass           def   init   self               MySuperClass   init   self     2  to make code more abstract  and more portable   A common method to get Super-Class is invented like       super  lt class gt    lt instance gt     And init function can be       class MySubClassBetter MySuperClass           def   init   self               super MySubClassBetter  self    init       However  requiring an explicit passing of both the class and instance break the DRY  Don t Repeat Yourself  rule a bit     3  in V3  It is more smart        super     is enough in most case  You can refer to http   www python org dev peps pep-3135

[python] Python extending with - using super() Python 3 vs Python 2

Examples related to python

Examples related to inheritance

Examples related to configparser