Python super：调用基类方法，该方法包含另一个被派生类重写的基类方法 A类（对象）： def foo（self）： 打印“A-foo” def foo2（自我）： 打印“foo2” self.foo（） B（A）类： def foo（self）： 打印“B-foo” def foo2（自我）： super（B，self）.foo2（） B（）.foo2（）

我正试图让[参议员1]：

foo2
A - foo

但是我得到了[senario2]：

foo2
B - foo

相反

---

我发现了，但我想知道是否有一种方法可以在不更改类

a

中方法

foo

的名称的情况下生成[senario1]

一种方法是在

A

上调用

foo

并手动将

self

传递给它：

---

这样，您将始终在

A

上调用

foo

。如果这个

foo

将调用

self.foo（）

，那么它将再次调用

B

s foo方法。

正如Leon指出的，您可以通过通过

A.foo

硬编码显式调用并将实例对象作为参数传递，简单地访问

A

类中的

foo

方法，然而，正如拉温所说，这不是一个好的解决方案。实际上，这是错误的类设计的例子。为什么?

想象一下，在一个更大的项目中，您将通过

a.foo

在数百个地方使用显式调用。现在，尝试将

A

类重命名为

MagicUnicorn

类

这是违反直觉的。如果在

B

中覆盖

A

中的

foo

方法，则在99.9999%的情况下不需要覆盖

A

中的

foo

，因为必须有理由覆盖它

一个比使用显式调用更好的解决方案是在

B

中重命名

foo

（正如Rawing所说）：

---

您可以更改

A.foo2

，以便它显式调用

A.foo（self）

，但这并不是一个好的解决方案。我认为最合适的修复方法是更改

B.foo

的名称。如果它不应该覆盖

A.foo

，那么，好吧，不要覆盖

A.foo

。我想知道如果你在

B.foo2

里面说类似于

self的话会发生什么事。在一个简单的例子中，我已经测试了这一点，它按照预期工作，可能是您想要的。
class A(object):
    def foo(self):
        print("A - foo")
    def foo2(self):
        print("foo2")
        A.foo(self)

class B(A):
    def foo(self):
        print("B - foo")
    def foo2(self):
        super(B, self).foo2()

B().foo2()

class A(object):
    def foo(self):
        print "A - foo"
    def foo2(self):
        print "foo2"
        self.foo()

class B(A):
    def unicorn_foo(self):
        print "B - foo"
    def foo2(self):
        super(B, self).foo2()

B().foo2()