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

是否可以在methodb()中致电parent.py？

Answer 1

如果A是一个抽象基类，这样做才有意义，这意味着A仅用作其他类的基础，而不是直接实例化。如果是这种情况，您可以在A类上定义methodB，但保持未实现：

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

这不是必须的。如果您未在methodB中的任何位置声明A，并实例化B，那么您仍然可以从{{{1}的正文中调用methodB 1}}，但这是一种不好的做法;它不清楚methodA应该来自哪里，或者子类需要覆盖它。

如果您想要更正式，可以使用Python abc模块将A声明为抽象基类。

methodA

使用此选项实际上会阻止您在不覆盖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")的情况下实例化A或从A继承的任何类。例如，如果B看起来像这样：

methodB

尝试实例化它时会出错：

class B(A):
   pass

如果您尝试实例化Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: Can't instantiate abstract class B with abstract methods methodB，则会发生同样的情况。

Answer 2

您可以这样做：

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

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

注意，实际上没有来自父级的调用，只是从子类的实例中调用了函数foo，这个实例从父级继承了foo，即这是不可能的：< / p>

a=A()
a.foo()

会产生： AttributeError: A instance has no attribute 'testb'

，因为

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

我想表明你可以创建子类的实例，它将拥有来自父类和它自己的类的所有方法和参数。

Answer 3

您可以在的任何位置使用该功能，只要它附加到对象，它似乎来自您的样本。如果你有一个B对象，那么你可以在任何地方使用它的methodb()函数。

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

导入后，您可以看到它的工作原理：

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

当然，您将无法在B内创建新的parent.py对象，但如果将其传入{{1}中的函数，您仍然可以使用它的方法不知何故。

Answer 4

有三种方法可以做到这一点！但我强烈建议使用方法3，因为在设计模式方面，组合/去耦具有某些好处。（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 5

如果两个类都在同一个.py文件中，则可以直接从父类调用子类方法。它给了我警告，但运行良好。

A类（对象）：

def methodA(self):

    print("in methodA")

    Self.methodb()

B（A）级：

def methodb(self):

    print("am in methodb")

从python中的父类文件调用子类方法

5 个答案: