calling child class method from parent class file in python

Question

parent.py :

class A(object):
    def methodA(self):
        print("in methodA")

child.py :

from parent import A
class B(A):
    def methodb(self):
        print("am in methodb")

Is there anyway to call methodb() in parent.py ?

Answer 1

Doing this would only make sense if A is an abstract base class, meaning that A is only meant to be used as a base for other classes, not instantiated directly. If that were the case, you would define methodB on class A, but leave it unimplemented:

class A(object):
    def methodA(self):
        print("in methodA")

    def methodB(self):
        raise NotImplementedError("Must override methodB")


from parent import A
class B(A):
    def methodB(self):
        print("am in methodB")

This isn't strictly necessary. If you don't declare methodB anywhere in A , and instantiate B , you'd still be able to call methodB from the body of methodA , but it's a bad practice; it's not clear where methodA is supposed to come from, or that child classes need to override it.

If you want to be more formal, you can use the Python abc module to declare A as an abstract base class.

from abc import ABCMeta, abstractmethod

class A(object):
 __metaclass__ = ABCMeta

    def methodA(self):
        print("in methodA")

    @abstractmethod
    def methodB(self):
        raise NotImplementedError("Must override methodB")

Using this will actually prevent you from instantiating A or any class that inherits from A without overriding methodB . For example, if B looked like this:

class B(A):
   pass

You'd get an error trying to instantiate it:

Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class B with abstract methods methodB

The same would happen if you tried instantiating A .

Answer 2

You can do something like this:

class A():
    def foo(self):
        self.testb()

class B(A):
    def testb(self):
        print('lol, it works')
b = B()
b.foo()

Which would return this of course:

lol, it works

Note, that in fact there is no call from parent, there is just call of function foo from instance of child class, this instance has inherited foo from parent, ie this is impossible:

a=A()
a.foo()

will produce: AttributeError: A instance has no attribute 'testb'

because

>>> dir(A)
['__doc__', '__module__', 'foo']
>>> dir(B)
['__doc__', '__module__', 'foo', 'testb']

What I've wanted to show that you can create instance of child class, and it will have all methods and parameters from both parent and it's own classes.

Answer 3

There are three approaches/ways to do this ! but I highly recommend to use the approach #3 because composition/decoupling has certain benefits in terms of design pattern. ( GOF )

## approach 1 inheritance 
class A():
    def methodA(self):
        print("in methodA")
    def call_mehtodB(self):
        self.methodb()

class B(A):
    def methodb(self):
        print("am in methodb")

b=B()
b.call_mehtodB()


## approach 2 using abstract method still class highly coupled
from abc import ABC, abstractmethod
class A(ABC):
    def methodA(self):
        print("in methodA")
    @abstractmethod    
    def methodb(self):
       pass

class B(A):

    def methodb(self):
        print("am in methodb")

b=B()
b.methodb()

#approach 3 the recommended way ! Composition 

class A():
    def __init__(self, message):
        self.message=message

    def methodA(self):
        print(self.message)

class B():
    def __init__(self,messageB, messageA):
        self.message=messageB
        self.a=A(messageA)

    def methodb(self):
        print(self.message)

    def methodA(self):
        print(self.a.message)

b=B("am in methodb", "am in methodA")
b.methodb()
b.methodA()

Answer 4

You could use the function anywhere so long as it was attached to an object , which it appears to be from your sample. If you have a B object, then you can use its methodb() function from absolutely anywhere.

parent.py:

class A(object):
    def methoda(self):
        print("in methoda")

def aFoo(obj):
  obj.methodb()

child.py

from parent import A
class B(A):
    def methodb(self):
        print("am in methodb")

You can see how this works after you import:

>>> from parent import aFoo
>>> from child import B
>>> obj = B()
>>> aFoo(obj)
am in methodb

Granted, you will not be able to create a new B object from inside parent.py , but you will still be able to use its methods if it's passed in to a function in parent.py somehow.

Answer 5

If the both class in same .py file then you can directly call child class method from parents class. It gave me warning but it run well.

class A(object):

def methodA(self):

    print("in methodA")

    Self.methodb()

class B(A):

def methodb(self):

    print("am in methodb")

Answer 6

You can certainly do this -

parent.py

class A(object):
    def __init__(self,obj):
        self.obj_B = obj

    def test(self):        
        self.obj_B.methodb()

child.py

from parent import A

class B(A):
    def __init__(self,id):
        self.id = id
        super().__init__(self)
   
    def methodb(self):
        print("in method b with id:",self.id)

Now if you want to call it from class B object

b1 = B(1)
b1.test()

>>> in method b with id: 1

Or if you want to call it from class A object

b2 = B(2)
a = A(b2)
a.test()

>>> in method b with id: 2

You can even make new objects in super class by invoking class dict objects of the object passed to super class from child class.