如何在 python 中参数化 Mixins，而不显式调用它们的构造函数？

Question

我想在 python 中更多地使用 Mixins 并且喜欢以下模式：

class Person:
  [...]

class Greetable:
  greeting: str

  def __init__(*args, **kwargs):
    super().__init(*args, **kwargs)
    ... greeting related setup

  def greet(self):
    print(f"{self.greeting} sir or madam!")

class Sailor(Greetable, Person):
  def __init__(self):
    super().__init__()

    self.greeting = "Ahoy"

>>> Sailor().greet()
"Ahoy sir or madam!"

但我还没有解决参数化混入的问题。在我的工作中，我看到很多明确的__init__ 调用超类alá

class A(B, FloorMixin):
  def __init__(desk, chair, floor):
    B.__init__(self, desk, chair)
    FloorMixin.__init__(floor)

我看到了分解参数并显式分配它们的用途，但我想保留上述 Mixin 示例的 __init__ 的“passthrough”属性。

我只能考虑将 Mixin 的所有参数都作为特定的关键字参数，从 **kwargs 参数中获取 pop'ed 或者仅依赖于 mixin 中存在的字段并且必须在之前设置它们，这会将最后一个示例变成：

class A(FloorMixin, B):
  def __init__(desk, chair, floor):
    self._floor = floor  # FloorMixin expects a _floor attribute

    super().__init__(desk, chair)

Answer 1

正确使用super 的关键是层次结构中涉及的每个类都应该假设其他所有人也会调用super。对于除object 之外的每个类都是如此，object 始终是任何继承层次结构中的根类。

你的例子

class A(B, FloorMixin):
  def __init__(self, desk, chair, floor):
    B.__init__(self, desk, chair)
    FloorMixin.__init__(floor)

这意味着A、B 和FloorMixin 都应该调用super().__init__，并且在实例化A 时应该使用关键字参数，这样就不会有基于排序的冲突。

class B:
    def __init__(self, desk, chair, **kwargs):
        super().__init__(**kwargs)
        # Do stuff with desk and chair

class FloorMixin:
    def __init__(self, floor, **kwargs):
        super().__init__(**kwargs)
        # Do stuff with floor

class A(B, FloorMixin):
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        # If there's nothing else to do, you don't
        # even need to define A.__init__

# With keyword arguments, order doesn't matter
# Each __init__ will find the arguments it needs
# and pass on the rest
a = A(floor="...", chair="...", desk="...")

A 的方法解析顺序是[A, B, FloorMixin, object]，因此每次对super().__init__ 的调用都会从行中的下一个类调用__init__。 A.__init__ 调用B.__init__，后者调用FloorMixin.__init__，后者调用object.__init__。重要的是，请注意，这意味着在运行时，B.__init__ 调用了B 的作者甚至可能不知道的类的__init__。这就是为什么接受意料之外的关键字参数并传递它们很重要的原因。