如何使用父类对象调用子类方法

Question

I am a bit new to Python inheritance. I have a code something like this

class Parent(object):
'''
Class for Parent
'''

def __init__(self, host, user, password):
    self.host = host
    self.user = user
    self.password = password
    self.child = Child()

def method1(self,param1, param2, param3):
    self.child.method1(param1, param2, param3)

The below is the child class. Both parent and child classes are in the same file

class Child(Parent):
'''
Class for Child
'''
  def __init__(self):
    super(Child).__init__()

  def method1(self, param1, param2, param3):
    // My actual code will be here

Now, I have another python script where I would initialize the parent object and call method1

 client = Parent(host, user, password)
 client.method1(param1, param2, param3)

With the above approach, I am expecting that the method1 of Child will get executed. But it is not. I am getting the following error

 TypeError: super() takes at most 1 argument (0 given)

What is the solution for this..? Where am I doing wrong..?

Answer 1

In Python 2, super takes two arguments, as the error message explains. You use it like this:

super(Child, self).__init__()

However, you also have to pass along all the required arguments to __init__ . Since your Parent takes a host , user , and password , you need these to super the initializer. So you probably want something like this in Child :

def __init__(self, host, user, password):
    super(Child, self).__init__(host, user, password)

Although since Child.__init__ doesn't actually do anything besides try to super , the simpler thing to do is to just not override __init__ in the first place.

At any rate, once you solve the super problem, either way, you're just going to have an infinite recursion—the Parent creates a Child() , which supers the Parent constructor and therefore creates another Child() , and so on until you get an exception.

In fact, your design is very weird. It's rare that an object needs to hold a reference to (much less create) an instance of one of its subclasses. Normally, you just want to use inheritance as inheritance. Something like this:

class Parent(object):
    '''
    Class for Parent
    '''

    def __init__(self, host, user, password):
        self.host = host
        self.user = user
        self.password = password
        self.child = Child()

class Child(Parent):
    def method1(self, param1, param2, param3):
        # actual code here

Now, if you create a child = Child(host, user, password) , you can call child.method1(arg1, arg2, arg3) on it. If you want to provide a default implementation in Parent , you can. You can even make it a pre- or post-implementation that Child and any other children call via super before or after their own code. Which one you actually want is impossible to say with this toy model, but for real classes it's usually pretty obvious.

Answer 2

I managed to achieve this with the help of a Singleton class. This is what I have done. This is the parent class.

class Parent(object):
'''
Class for Parent
'''

def __init__(self, host, user, password):
    self.host = host
    self.user = user
    self.password = password

def helper_method1():
    // Implementation

Then I've created a singleton class

class ParentObjMgr(object):
    '''
    A Singleton that stores the objects of different child classes.
    The child class needs to be instantiated here.
    This class needs to be instantiated in the caller.
    '''
    __metaclass__ = Singleton

    def __init__(self, host, user, password):
        self._host = host
        self._user = user
        self._password = password
        self._child1 = None
        self._child2 = None

    def get_child1(self):
        if not self._child1:
            self._child1 = Child1(self._host, self._user, self._password)
        return self._child1

    def get_child2(self):
        if not self._child2:
            self._child2 = Child2(self._host, self._user, self._password)
        return self._child2

Now I will implement child classes

class Child1(Parent):
    // Implementation

class Child2(Parent):
    // Implementation
    self.helper_method1()

Now in the caller, I would do this

parent_object_mgr=ParentObjMgr(self.host, self.user, self.password)                  
child1=parent_object_mgr.get_child1()
child2=parent_object_mgr.get_child2()

This is how I have managed to access all the child class objects with the help of a single class object. Now, I don't have to instantiate the child classes, wherever they are being called and that is what I was looking for. Please let me know if it is an efficient solution (or) is there anything I need to do to improve it. Thanks