Python 从超类调用子类中类似的命名函数

一份来自的后续报告，没有很好地制定。这个答案提供了一些额外的见解，所以现在我构建了一个有限的工作示例来更好地解释它

基本上我们有两个子类

A

和

B

，还有一个类

C

，它继承了这两个类。类

A

和

B

都有一个函数

MyFunc

，但其功能不同

我希望class

C

能够同时使用这两个函数，并且能够完全控制调用哪个函数，因为我希望对每个函数执行不同的操作。下面有限工作示例中的注释显示了我正在尝试做的事情

class A（）：
定义初始化（self，var1，var2）：
self.var1=var1
self.var2=var2
def MyFunc（自我）：
结果=self.var1+self.var2
返回结果
B类（）：
定义初始化（self，var1）：
self.var1=var1
def MyFunc（自我）：
结果=自身变量1**2
返回结果
丙类（甲、乙类）：
定义初始化（self，var1，var2，var3）：
A.。uuuu初始（self，var1，var2）
B.uuu初始化（self，var3）
def MyFunc（自我）：
#在这个函数中，我想从A调用MyFunc，从B调用MyFunc。例如，将它们的结果相加

---

如何从

C

中的

MyFunc

调用

A

中的

MyFunc

和

B

中的

MyFunc

？

我尝试使用您的示例建议使解决方案尽可能简单

    def MyFunc(self):
        result = 0
        result += A.MyFunc(self=self)
        result += B.MyFunc(self=self)
        return result

---

我尝试使用您的示例建议使解决方案看起来尽可能简单

    def MyFunc(self):
        result = 0
        result += A.MyFunc(self=self)
        result += B.MyFunc(self=self)
        return result

---

即使子类定义了具有相同名称的属性，也可以使用名称混乱使子类中的类的属性可用

class A():
    def __init__(self, var1, var2):
        self.var1 = var1
        self.var2 = var2
    def __MyFunc(self):
        result = self.var1 + self.var2
        return result
    MyFunc = __MyFunc

class B():
    def __init__(self, var1):
        self.var1 = var1
    def __MyFunc(self):
        result = self.var1**2
        return result
    MyFunc = __MyFunc

class C(A,B):
    def __init__(self, var1, var2, var3):
        A.__init__(self, var1, var2)
        B.__init__(self, var3)
    def MyFunc(self):
        return self._A__MyFunc() + self._B__MyFunc()

c = C(1, 2, 3)
print(c.MyFunc())
# 14

---

即使子类定义了具有相同名称的属性，也可以使用名称混乱使子类中的类的属性可用

class A():
    def __init__(self, var1, var2):
        self.var1 = var1
        self.var2 = var2
    def __MyFunc(self):
        result = self.var1 + self.var2
        return result
    MyFunc = __MyFunc

class B():
    def __init__(self, var1):
        self.var1 = var1
    def __MyFunc(self):
        result = self.var1**2
        return result
    MyFunc = __MyFunc

class C(A,B):
    def __init__(self, var1, var2, var3):
        A.__init__(self, var1, var2)
        B.__init__(self, var3)
    def MyFunc(self):
        return self._A__MyFunc() + self._B__MyFunc()

c = C(1, 2, 3)
print(c.MyFunc())
# 14

---

看起来不错，但为什么结果是14？不是12点吗？1+2+3**2=12

c

有两个var属性

var1

和

var2

var1

是

3

和

var2

是

2

。你知道为什么吗？不太明白。。。。我认为C的init方法应该考虑到这一点，并给出

C

var1=1、var2=2和var3=3。我在这里遗漏了什么？没有一个类定义了

self.var3

。因此

C

从

A

获取

var1

和

var2

。然后从

B

获取

var1

，这将覆盖从

A

获取的

var1

。这是给事物起描述性名称很重要的原因之一。在这种情况下，

A.\uuu init\uuuu（self，var1，var2）

做什么？它是否将类

C

传递到

A

？我很困惑，看起来不错，但为什么结果是14？不是12点吗？1+2+3**2=12

c

有两个var属性

var1

和

var2

var1

是

3

和

var2

是

2

。你知道为什么吗？不太明白。。。。我认为C的init方法应该考虑到这一点，并给出

C

var1=1、var2=2和var3=3。我在这里遗漏了什么？没有一个类定义了

self.var3

。因此

C

从

A

获取

var1

和

var2

。然后从

B

获取

var1

，这将覆盖从

A

获取的

var1

。这是给事物起描述性名称很重要的原因之一。在这种情况下，

A.\uuu init\uuuu（self，var1，var2）

做什么？它是否将类

C

传递到

A

？我很困惑