在Python中如何从子类调用和重写父类方法

Question

在ResistantVirus类的reproduce方法中，我试图调用SimpleVirus类的reproduce(self, popDensity)，但是我希望它返回一个SimpleVirus对象，而不是返回一个ResistantVirus对象。在

显然，我也可以重复SimpleVirus.reproduce方法中的一些代码，并在我的ResistantVirus.reproduce方法中使用相同的实现，但是我想知道是否可以调用并重写{}以避免重复？在

class SimpleVirus(object):

    def __init__(self, maxBirthProb, clearProb):
        self.maxBirthProb = maxBirthProb
        self.clearProb = clearProb

    def reproduce(self, popDensity):
        if random.random() > self.maxBirthProb * (1 - popDensity):
            raise NoChildException('In reproduce()')
        return SimpleVirus(self.getMaxBirthProb(), self.getClearProb())


class ResistantVirus(SimpleVirus):

    def __init__(self, maxBirthProb, clearProb, resistances, mutProb):
        SimpleVirus.__init__(self, maxBirthProb, clearProb)
        self.resistances = resistances
        self.mutProb = mutProb

    def reproduce(self, popDensity)       

      ## returns a new instance of the ResistantVirus class representing the       
      ## offspring of this virus particle. The child should have the same   
      ## maxBirthProb and clearProb values as this virus.

      ## what I sketched out so far and probs has some mistakes:
      for drug in activeDrugs:
          if not self.isResistantTo(drug):
              raise NoChildException
              break

      simple_virus = SimpleVirus.reproduce(self,popDensity)

      return ResistantVirus(simple_virus.getMaxBirthProb(),simple_virus.getClearProb())

Answer 1

只要__init__()签名兼容，就可以使用实例的类型而不是显式类型。在

class Parent(object):
    def __str__(self):
        return 'I am a Parent'

    def reproduce(self):
        # do stuff common to all subclasses.
        print('parent reproduction')
        # then return an instance of the caller's type
        return type(self)()

class Child(Parent):
    def __str__(self):
        return 'I am a Child'

    def reproduce(self):
        # do stuff specific to Child.
        print('child reproduction')
        # call the parent's method but it will return a
        # Child object
        return super(Child, self).reproduce()


print(Parent().reproduce())

parent reproduction    
I am a Parent

print(Child().reproduce())

child reproduction
parent reproduction
I am a child

Answer 2

使用super调用父类的方法：

class ResistantVirus(SimpleVirus):
    def __init__(self, maxBirthProb, clearProb, resistances, mutProb):
        self.resistances = resistances
        self.mutProb = mutProb
        super(ResistantVirus, self).__init__(maxBirthProb, clearProb)

    def reproduce(self, popDensity):
        simple_virus = super(ResistantVirus, self).reproduce(popDensity)
        resistances = # TODO
        mutProb = # TODO
        return ResistantVirus(simple_virus.maxBirthProb,
                              simple_virus.clearProb, 
                              resistances, 
                              mutProb)

Answer 3

看起来^{}可以帮你。在

import copy

class Parent(object):
    def __init__(self, a):
        self.a = a

    def copy(self):
        return copy.deepcopy(self)

class Child(Parent):
    def __init__(self, a, b):
        super(Child, self).__init__(a)
        self.b = b

copy方法将携带self是什么的类（不一定是父类）。例如：

^{pr2}$

这似乎是你的主要目标。然而，在如何构建测试结构方面也值得付出一些努力。我使用您的示例代码实现了一个不同的解决方案，它允许您继承测试。请注意，需要向病毒传递一个关键字参数列表（**kwargs）。下面给出了用法示例。在

import copy, random

class SimpleVirus(object):

    def __init__(self, max_birth_prob, clear_prob):
        self.max_birth_prob = max_birth_prob
        self.clear_prob = clear_prob
        self._tests = [self.simple_test]

    def copy(self):
        return copy.deepcopy(self)

    def simple_test(self, **kwargs):
        return random.random() < self.max_birth_prob * (1 - kwargs['pop_density'])

    def reproduce(self, **kwargs):
        if all(test(**kwargs) for test in self._tests):
            return self.copy()
        raise Exception


class ResistantVirus(SimpleVirus):

    def __init__(self, max_birth_prob, clear_prob, resistances, mut_prob):

        super(ResistantVirus, self).__init__(max_birth_prob, clear_prob)
        self.resistances = resistances
        self.mut_prob = mut_prob
        self._tests.append(self.resistance_test)

    def resistance_test(self, **kwargs):
        return all(drug in self.resistances for drug in kwargs['drug_list'])

下面的内容有时会复制，有时会引发Exception。在

res_virus = ResistantVirus(0.8, 0.2, ['a', 'b', 'c'], 0.1)
res_virus.reproduce(pop_density=0.3, drug_list=['a', 'b'])

请注意，这两个类之间没有显著的代码重用。如果你有一个严格的继承链，并且事情会随着你的发展而“积累”，这是很好的。但是，如果有很多类都继承SimpleVirus，并且其中一些类共享功能，那么值得研究一下object composition over inheritance。在