python - MRO、super 在 python 中如何工作

Question

有人可以帮我理解 MRO 在 python 中的工作原理吗？假设我有四个职业——性格、小偷、敏捷、潜行。角色是 Thief 的 super 类别，Agile 和 Sneaky 是 sibling 。请参阅下面我的代码和问题

class Character:
    def __init__(self, name="", **kwargs):
        if not name:
            raise ValueError("'name' is required")
        self.name = name

        for key, value in kwargs.items():
            setattr(self, key, value)


class Agile:
    agile = True

    def __init__(self, agile=True, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.agile = agile


class Sneaky:
    sneaky = True

    def __init__(self, sneaky=True, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.sneaky = sneaky


class Thief(Agile, Sneaky, Character):
    def pickpocket(self):
    return self.sneaky and bool(random.randint(0, 1))


parker = Thief(name="Parker", sneaky=False)

所以，这就是我认为正在发生的事情，请告诉我我的理解是否正确。

由于 Agile 位于列表的第一位，因此所有参数都会首先发送到 Agile，参数将与 Agile 参数交叉引用。如果存在匹配，则将分配该值，然后所有没有匹配关键字的内容都将打包在 *kwargs 中并发送到 Sneaky 类(通过 super)，在那里会发生相同的事情 - 所有参数都被解包，与 Sneaky 参数交叉引用(这是在设置 Sneaky = False 时)，然后打包在 kwargs 中并发送给 Character。然后，Character inint 方法中的所有内容都将运行，并且所有值都将被设置(例如 name =“Parker”)。

我认为 MRO 在回来的路上如何发挥作用

现在所有内容都已进入Character类并且Character init方法中的所有内容都已运行，现在它必须返回Agile和Sneaky类并完成运行其init方法中的所有内容(或它们的 super 下的所有内容)。因此，它将首先返回到 Sneaky 类并完成其 init 方法，然后返回到 Agile 类并完成其 init 方法的其余部分(分别)。

我有什么地方感到困惑吗？唷。抱歉，我知道这很多，但我真的被困在这里，我正在努力清楚地了解 MRO 的工作原理。

谢谢大家。

Answer 1

您发布的代码甚至无法编译，更不用说运行了。但是，猜测它应该如何工作......

是的，你的情况基本上是正确的。

但是您应该能够通过两种方式自己验证这一点。知道如何验证它可能比知道答案更重要。

<小时/>

首先，打印出Thief.mro()。它应该看起来像这样:

[Thief, Agile, Sneaky, Character, object]

然后您可以看到哪些类提供了 __init__ 方法，以及如果每个人都只调用 super 的话它们将如何链接起来:

>>> [cls for cls in Thief.mro() if '__init__' in cls.__dict__]
[Agile, Sneaky, Character, object]

而且，只是为了确保Agile确实首先被调用:

>>> Thief.__init__
<function Agile.__init__>

<小时/>

其次，您可以在调试器中运行代码并单步执行调用。

或者您可以在每个语句的顶部和底部添加 print 语句，如下所示:

def __init__(self, agile=True, *args, **kwargs):
    print(f'>Agile.__init__(agile={agile}, args={args}, kwargs={kwargs})')
    super().__init__(*args, **kwargs)
    self.agile = agile     
    print(f'<Agile.__init__: agile={agile}')

(您甚至可以编写一个装饰器来自动执行此操作，并使用一点 inspect 魔法。)

如果你这样做，它会打印出类似的内容:

> Agile.__init__(agile=True, args=(), kwargs={'name': 'Parker', 'sneaky':False})
> Sneaky.__init__(sneaky=False, args=(), kwargs={'name': 'Parker'})
> Character.__init__(name='Parker', args=(), kwargs={})
< Character.__init__: name: 'Parker'
< Sneaky.__init__: sneaky: False
< Agile.__init__: agile: True

<小时/>

所以，你关于通过 super 调用事物的顺序是正确的，而堆栈在返回时弹出的顺序显然是完全相反的。

<小时/>

但是，与此同时，你有一个细节错误:

sent to the Sneaky class (via super), where the same thing will happen - all arguments get unpacked, cross-referenced with the Sneaky parameters (this is when sneaky = False is set)

这是设置参数/局部变量 sneaky 的位置，但 self.sneaky 直到之后才被设置>super 返回。在那之前(包括在 Character.__init__ 期间，以及类似地，对于您选择在 Sneaky 之后添加的任何其他 mixin)，不存在 sneaky在 self.__dict__ 中，因此如果有人尝试查找 self.sneaky，他们只能找到 class 属性，而该属性的值是错误的。

<小时/>

这提出了另一个问题:这些类属性有什么用？如果您希望它们提供默认值，那么您已经在初始化参数上获得了默认值，因此它们是无用的。

如果您希望它们在初始化期间提供值，那么它们可能是错误的，因此它们比无用更糟糕。如果在调用 Character.__init__ 之前需要有一个 self.sneaky，方法很简单:只需移动 self.sneaky = Sneaky > 在 super() 调用之前。

事实上，这是 Python 的“显式 super”模型的优势之一。在某些语言中，比如 C++，构造函数总是被自动调用，无论是从内到外还是从外到内。Python 强制你显式地调用它不太方便，而且更难出错——但这意味着你可以选择在之前进行设置或者在基类获得机会之后(或者，当然，每种都有一点)，这有时很有用。