MRO, super 如何在 python 中工作

菲利普·舒尔茨

有人可以帮助我了解 MRO 在 python 中的工作原理吗?假设我有四个类 - Character、Thief、Agile、Sneaky。Character 是 Thief 的超类,Agile 和 Sneaky 是兄弟姐妹。请在下面查看我的代码和问题

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)

所以,这就是我的想法,如果我理解正确,请告诉我。

由于敏捷是列表中的第一个,所有参数首先发送到敏捷,在那里参数将与敏捷参数交叉引用。如果匹配,则将分配值,然后所有没有匹配关键字的内容都将打包在 *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 的工作原理。

谢谢大家。

阿巴纳特

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

是的,你的事情基本上是正确的。

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


首先,只需打印出来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,而堆栈在返回的路上弹出的顺序显然是完全相反的。


但是,与此同时,您弄错了一个细节:

发送到 Sneaky 类(通过 super),在那里会发生同样的事情 - 所有参数都被解包,与 Sneaky 参数交叉引用(这是当设置了 Sneaky = False 时)

这是其中参数/局部变量sneaky获取设置,但self.sneaky不被设置到super回报。在那之前(包括 during Character.__init__,以及类似地对于您选择在之后放入的任何其他混入Sneaky),没有sneakyin self.__dict__,因此如果有人试图查找self.sneaky,他们只能找到 class 属性 - 它具有错误的值。


这就引出了另一点:这些类属性是做什么用的?如果您希望它们提供默认值,那么您已经在初始值设定项参数上获得了默认值,因此它们毫无用处。

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

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

本文收集自互联网,转载请注明来源。

如有侵权,请联系 [email protected] 删除。

编辑于
0

我来说两句

0 条评论
登录 后参与评论

相关文章