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

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

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

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

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 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