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

Question

I want to use Mixins more in python and like the pattern of:

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!"

But I have yet to crack the problem of having parameterized mixins. In my job I see a lot of explicit __init__ calls to super classes alá

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

I see the use in breaking up the parameters and distributing them explicitely, but I would like to keep the "passthrough" property the __init__ of the above Mixin example has.

I could only think of having all arguments to the Mixin as specific keyword arguments, which get pop 'ed out of the **kwargs parameter or only relying on fields being present in the mixin and having to set them before, which would turn the last example into:

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

    super().__init__(desk, chair)

Answer 1

The key to using super properly is that every class involved in the hierarchy should assume that everyone else will also call super . That's true for every class except object , which is always the root class in any inheritance hierarchy.

For your example

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

that means that A , B , and FloorMixin should all calling super().__init__ , and you should use keyword arguments when instantiating A so that there are no ordering-based conflicts.

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="...")

The method resolution order for A is [A, B, FloorMixin, object] , so each call to super().__init__ calls __init__ from the next class in line. A.__init__ calls B.__init__ , which calls FloorMixin.__init__ , which calls object.__init__ . Importantly, note that this means that at runtime , B.__init__ calls __init__ of a class that the author of B may not even have known about. That's why it's important to accept unexpected keyword arguments and to pass them on.