派生类可以覆盖其基类的方法。由于方法在调用同一对象的其他方法时没有特殊权限，因此基类的方法调用同一基类中定义的另一个方法可能最终会调用覆盖它的派生类的方法。
这是怎么发生的？有人可以用一个简单的例子来说明这个概念吗？
【问题讨论】：
标签： python python-3.x class inheritance
这是您要求的示例。这将打印chocolate。
class Base:
def foo(self):
print("foo")
def bar(self):
self.foo()
class Derived(Base):
def foo(self):
print("chocolate")
d = Derived()
d.bar() # prints "chocolate"
字符串chocolate 被打印而不是foo，因为Derived 覆盖了foo() 函数。即使bar() 在Base 中定义，它最终还是调用foo() 的Derived 实现而不是Base 实现。
【讨论】：
Base 的instance 方法永远无法执行Derived 的方法？我原以为文档是在暗示的。
d 也是Base 的一个实例，这可能是造成混淆的原因。但是是的，Base().bar() 不会调用任何被覆盖的方法
b = Base(); b.foo = Derived.foo.__get__(b); b.bar()。但是如果没有你明确地为它输入代码，这永远不会发生。
当对类的实例执行属性查找时，类字典和其基类的字典按一定的顺序（参见：Method Resolution Order）搜索适当的方法。 first 找到的内容将被调用。
使用以下Spam 示例：
class Spam:
def produce_spam(self):
print("spam")
def get_spam(self):
self.produce_spam()
class SuperSpam(Spam):
def produce_spam(self):
print("super spam")
Spam 定义了函数produce_spam 和get_spam。这些存在于其Spam.__dict__（类命名空间）中。子类SuperSpam 通过继承可以访问这两种方法。 SuperSpam.produce_spam 不会替换 Spam.produce_spam，它只是在其一个实例上查找名称 'produce_spam' 时首先找到的。
从本质上讲，继承的结果是，如果在对子类进行属性查找后，在子类的字典。
当函数get_spam第一次被调用时：
s = SuperSpam()
s.get_spam()
事件的顺序大致是这样的：
SuperSpams __dict__ 以获得get_spam。SuperSpams __dict__ 中找不到它，请查看它的基类字典（mro 链）。 Spam 是 mro 链中的下一个，因此 get_spam 可以在 Spam 的字典中找到。现在，当produce_spam 与self.produce_spam 在get_spam 的正文中查找时，序列要短得多：
SuperSpam 的 (self) __dict__ 获取 produce_spam。produce_spam 首先在__dict__ 中找到，以便获取。
【讨论】：
class Base():
def m1(self):
return self.m2()
def m2(self):
return 'base'
class Sub(Base):
def m2(self):
return 'sub'
b = Base()
s = Sub()
print(b.m1(), s.m1())
打印“基础子”
【讨论】：
为了说明它是如何工作的，请考虑以下两个类：
class Parent(object):
def eat(self):
print("I don't want to eat that {}.".format(self.takefrompocket()))
def takefrompocket(self):
return 'apple'
def __getattribute__(self, name):
print('Looking for:', name)
method_to_use = object.__getattribute__(self, name)
print('Found method:', method_to_use)
return method_to_use
class Child(Parent):
def takefrompocket(self):
return 'salad'
__getattribute__ 方法在新样式类（如 python3 中的所有类）中负责属性查找。它只是针对print 实现每个查找所做的 - 通常您不想也不应该自己实现它。如果您真的感兴趣，则查找遵循 pythons method resolution order (MRO)。
>>> some_kid = Child()
>>> some_kid.eat()
Looking for: eat
Found method: <bound method Parent.eat of <__main__.Child object at 0x0000027BCA4EEA58>>
Looking for: takefrompocket
Found method: <bound method Child.takefrompocket of <__main__.Child object at 0x0000027BCA4EEA58>>
I don't want to eat that salad.
因此，当您想使用 eat 时，它在此示例中使用 Parent.eat。但是self.takefrompocket 是从Child 使用的。
>>> some_parent = Parent()
>>> some_parent.eat()
Looking for: eat
Found method: <bound method Parent.eat of <__main__.Parent object at 0x0000027BCA4EE358>>
Looking for: takefrompocket
Found method: <bound method Parent.takefrompocket of <__main__.Parent object at 0x0000027BCA4EE358>>
I don't want to eat that apple.
这两种方法都取自Parent。继承的类（通常）不会干扰它们的祖先！
【讨论】：
如果您的子类没有实现该方法，则引发异常！
class Base(object):
def something (self):
raise ('Not implemented')
【讨论】：