Python中的可堆叠特征

恭喜！你已经发现了什么时候使用继承.继承是程序员工具包中一个非常具体的工具，它解决了一个非常具体的问题，但是有很多糟糕的教程和糟糕的讲师试图用子类来敲打软件开发世界中的every钉.

你所拥有的是一个list，而不是一系列超类.如果你想要FinalEntity到have种trait ，那就是has-a种关系.我们用composition来模拟has-a种关系，而不是inheritance种.

也就是说，我们没有从它的所有特征中获得FinalEntity inherit个，而是拥有contain个它们.

class Trait1:
    def f(self):
        return ["a", "b"]

class Trait2:
    def f(self):
        return ["x"]

class Trait3:
    def f(self):
        return ["C"]

那么你的FinalEntity就可以简单地

class FinalEntity:

    def __init__(self, traits):
        self.traits = traits

    def f(self):
        return [value for trait in self.traits for value in trait.f()]

作为额外的好处，这使编写测试更容易way.你建议的FinalEntity对它的父母来说是tightly coupled，所以你不可能不嘲笑它的不同特征来测试它.但this FinalEntity有一个构造函数，可以免费直接插入并播放不同的特征.

请注意，如果你想使用继承，你只需要在子类中调用super，Python默认的方法解析顺序将完成剩下的工作.

class BaseEntity:
    def f(self):
        return []

class AbstractEntity1(BaseEntity):
    def f(self):
        return super.f() + ["a", "b"]

class AbstractEntity2(BaseEntity):
    @abstractmethod
    def f(self):
        return super.f() + ["x"]

class FinalEntity(AbstractEntity1, AbstractEntity2):
    def f(self):
        return super.f() + ["C"]

但是，同样，这将导致更脆弱的代码，更难测试.

不管它的价值是什么，你正在寻找的功能被称为method combinations.这在Python中是不可用的特性，但是一些语言，尤其是Common Lisp，开箱即用地支持这一功能.等同于您在Common Lisp中编写的代码是

(defclass base () ())
(defclass abstract1 (base) ())
(defclass abstract2 (base) ())
(defclass final (abstract1 abstract2) ())

(defgeneric f (value)
  (:method-combination append :most-specific-last))

(defmethod f append ((value abstract1))
  (list "a" "b"))

(defmethod f append ((value abstract2))
  (list "x"))

(defmethod f append ((value final))
  (list "C"))

(let ((instance (make-instance 'final)))
  (format t "~A~%" (f instance))) ;; Prints ("a" "b" "x" "C")

但是，再说一次，如果没有lot个聪明的反射技巧，这在Python中是不可用的.