在classB中使用classA方法，其中B覆盖此方法

Question

我知道这个 question。我的类似，但不一样，因为我覆盖了上述方法。而且我不能使用 @staticmethod 因为我需要在 self 以及 class.

的其他函数中使用它

我有 class Player 和 class Dealer。在 Player 中，我定义了一个名为 print_cards 的方法。在 class Dealer 我覆盖了这个方法。如何让 Dealer 实例使用 Player 的 print_cards 方法而不是它自己的方法？

class Player():
    def print_cards(self):
        print('I am in Player\'s class.')

class Dealer(Player):
    def print_cards(self):
        print('I am in Dealer\'s class.')

p = Player()
d = Dealer()

p.print_cards()
d.print_cards()

d.Player.print_cards()  # this is what I am thinking, but it is not valid python

>>> I am in Player's class.
>>> I am in Dealer's class.

Answer 1

你的意思是这样的？没有 super() 你不会完全重写父方法，只是重新定义它。（虽然不确定，但如果可以的话，我尽量避免继承）。

class Player():
    def print_cards(self):
        print('I am in Player\'s class.')

class Dealer(Player):
    def print_cards(self):
        print('I am in Dealer\'s class.')
    def print_player(self):
        super().print_cards()

p = Player()
d = Dealer()

p.print_cards()
d.print_cards()
d.print_player()

输出为：

I am in Player's class.
I am in Dealer's class.
I am in Player's class.

虽然指定为 Python 3 问题，但在 Python 2

中，您是如何做的

class Player(object):
    def print_cards(self):
        print('I am in Player\'s class.')

class Dealer(Player):
    def print_cards(self):
        print('I am in Dealer\'s class.')
    def print_player(self):
        super(Dealer, self).print_cards()

super 对 python 2 和 3 的工作方式不同。特别注意 def 语句 Player class:[=19 的区别=]

 class Player(object):

在 Python2 中称为 "new-style" class。默认情况下，Python 3 中的所有 classes 都是新式 classes 如果我没记错的话。另外请注意，super 需要一种类型的 class，您正在寻找其父对象，而 self 是绑定对象，是父对象 class 的子对象.

Answer 2

你可以用另一个自己调用class的实例方法。例如：

class Player():
    def print_cards(self):
        print('I am in Player\'s class.')

class Dealer(Player):
    def print_cards(self):
        print('I am in Dealer\'s class.')

p = Player()
d = Dealer()

p.print_cards()
d.print_cards()

Player.print_cards(d)  # Not an instance

输出：

I am in Player's class
I am in Dealer's class
I am in Player's class

这在这种情况下不是很有用。另一个例子：

class Being:
    def __init__(self):
        self.saying = "Patience is a virtue."
        self.home = "Earth"

    def say_virtue(self):
        print(self.saying)

    def say_home(self):
        print(self.home)

class Yoda:
    def __init__(self):
        self.saying = "Is patience virtue a."
        self.home = "Far galaxy away far."

    def say_virtue(self):
        print("Mean you 'Virtue say'?")

yoda = Yoda()
being = Being()

being.say_virtue()  # Says beings virtue
yoda.say_virtue()   # Says yodas virtue
Being.say_virtue(yoda)   # says Beings virtue with yodas `self.virtue`
# And as a side note:
print(yoda.say_home == being.say_home)  # Instances
print(Yoda.say_home == Being.say_home)  # Classes

## Prints:
Patience is a virtue.
Mean you 'Virtue say'?
Is patience virtue a.
False
True

Answer 3

经常有人说 superclass 中的方法可以用 super().method(self) 调用，这并不完全正确。

super 通常不是正确的做法，因为它不调用 superclass 中的方法，而是 下一个类型中的方法在当前对象的类型方法解析顺序中。 在多重继承的情况下，它可以调用您没有预料到的 class 中的方法：

class A(object):
    def say(self):
        print("I am A, just sayin'")

class B(A):
    def say(self):
        print("This is B, I let A speak for me")
        super().say()

B.say() 调用 A.say()，对吗？

错了，因为我们还有：

class C(A):
    def say(self):
        print("Hey it is me C")

class D(B, C):
    pass

现在我们创建一个 D 的实例，并在其上调用 say()：

D().say()

输出为：

This is B, I let A speak for me
Hey it is me C

也就是说，super()将执行从B.say委托给了classC，而B根本不知道，B既不是C的subclass也不是superclass。 super() 是用词不当；它真的应该被称为 next_type 之类的。因此，如果您知道 class 交付给什么，请不要使用 super 而是显式调用该方法：

class B(A):
    def say(self):
        print("This is B, I let A speak for me")
        A.say(self)

在classB中使用classA方法，其中B覆盖此方法

Use class A method in class B, where B overwrites this method

python

oop

python-3.x