用 python 中的父类方法覆盖 init

Question

我想做类似下面的事情（在 Python 3.7 中）：

class Animal:

    def __init__(self, name, legs):
        self.legs = legs
        print(name)

    @classmethod 
    def with_two_legs(cls, name):
        # extremely long code to generate name_full from name
        name_full = name
        return cls(name_full, 2)

class Human(Animal):

    def __init__(self):
        super().with_two_legs('Human')

john = Human()

基本上，我想用父项的 class 工厂方法覆盖子项 class 的 __init__ 方法。但是，所写的代码不起作用，并引发：

TypeError: __init__() takes 1 positional argument but 3 were given

我认为这意味着 super().with_two_legs('Human') 将 Human 作为 cls 变量传递。

1) 为什么这不像写的那样有效？我假设 super() 会 return superclass 的代理实例，所以 cls 会 Animal 对吗？

2) 即使是这种情况，我也不认为这段代码实现了我想要的，因为 class 方法 return 是 Animal 的一个实例，但我只是想以与 class 方法相同的方式初始化 Human，有什么方法可以实现我想要的行为吗？

我希望这不是一个非常明显的问题，我发现 super() 上的 documentation 有点令人困惑。

Answer 1

你通过调用 super 获得的代理对象仅用于定位要调用的 with_two_legs 方法（并且由于你没有在 Human 中覆盖它，你可以已使用 self.with_two_legs 得到相同的结果）。

As wim commented, your alternative constructor with_two_legs doesn't work because the Human class breaks the Liskov substitution principle 通过具有不同的构造函数签名。即使您可以获得调用 Animal 的代码来构建您的实例，您也会遇到问题，因为您最终会得到一个 Animal 个实例而不是 Human 个实例（所以其他Human 中的方法，如果你写了一些，将无法使用。

请注意，这种情况并不少见，许多 Python 子 class 与它们的父 class 具有不同的构造函数签名。但这确实意味着您不能自由地使用一个 class 代替另一个，就像尝试构造实例的 classmethod 一样。你需要避免这些情况。

在这种情况下，最好为 Animal 构造函数的 legs 参数使用默认值。如果没有传递替代数字，它可以默认为 2 支线。那么你就不需要 classmethod，当你重写 __init__:

时你也不会运行遇到问题

class Animal:
    def __init__(self, name, legs=2): # legs is now optional, defaults to 2
        self.legs = legs
        print(name)

class Human(Animal):
    def __init__(self):
        super().__init__('Human')

john = Human()

Answer 2

super().with_two_legs('Human') 实际上确实调用了 Animal 的 with_two_legs，但它将 Human 作为 cls 而不是 Animal。 super() 使代理对象仅用于协助方法查找，它不会更改传递的内容（它仍然是相同的 self 或 cls 它源自）。在这种情况下，super() 甚至没有做任何有用的事情，因为 Human 没有覆盖 with_two_legs，所以：

super().with_two_legs('Human')

表示"call with_two_legs from the first class above Human in the hierarchy which defines it"，并且：

cls.with_two_legs('Human')

表示"call with_two_legs on the first class in the hierarchy starting with cls that defines it"。只要 Animal 下面的 class 没有定义它，那些就做同样的事情。

这意味着您的代码在 return cls(name_full, 2) 处中断，因为 cls 仍然是 Human，并且您的 Human.__init__ 没有接受任何超出 self 的参数.即使你费力地让它工作（例如，通过添加两个你忽略的可选参数），这也会导致无限循环，因为 Human.__init__ 调用 Animal.with_two_legs，这反过来又试图构造一个 Human，再次调用 Human.__init__。

你想做的不是一个好主意；替代构造函数，就其本质而言，依赖于 class 的核心 constructor/initializer。如果您尝试创建一个依赖于替代构造函数的核心 constructor/initializer，那么您已经创建了循环依赖。

在这种特殊情况下，我建议避免使用备用构造函数，而是支持始终显式提供 legs 计数，或者使用执行的中间 TwoLeggedAnimal class您的替代构造函数的任务。如果你想重用代码，第二个选项意味着你的 "extremely long code to generate name_full from name" 可以进入 TwoLeggedAnimal 的 __init__；在第一个选项中，您只需编写一个 staticmethod 来提取该代码，以便 with_two_legs 和其他需要使用它的构造函数都可以使用它。

class 层次结构类似于：

class Animal:
    def __init__(self, name, legs):
        self.legs = legs
        print(name)

class TwoLeggedAnimal(Animal)
    def __init__(self, name):
        # extremely long code to generate name_full from name
        name_full = name
        super().__init__(name_full, 2)

class Human(TwoLeggedAnimal):
    def __init__(self):
        super().__init__('Human')

通用代码方法应该是这样的：

class Animal:
    def __init__(self, name, legs):
        self.legs = legs
        print(name)

    @staticmethod
    def _make_two_legged_name(basename):
        # extremely long code to generate name_full from name
        return name_full

    @classmethod 
    def with_two_legs(cls, name):
        return cls(cls._make_two_legged_name(name), 2)

class Human(Animal):
    def __init__(self):
        super().__init__(self._make_two_legged_name('Human'), 2)

旁注：即使您解决了递归问题，您尝试做的事情也不会奏效，因为 __init__ 不会生成新实例，它初始化现有实例。因此，即使您调用 super().with_two_legs('Human') 并且它以某种方式起作用，它也会创建并 returning 一个完全不同的实例，但不会对 __init__ 接收到的 self 做任何事情，这就是实际上正在创建。你能做的最好的事情是：

def __init__(self):
    self_template = super().with_two_legs('Human')
    # Cheaty way to copy all attributes from self_template to self, assuming no use
    # of __slots__
    vars(self).update(vars(self_template))

无法在 __init__ 中调用备用构造函数并隐式更改 self。关于在不创建辅助方法和保留备用构造函数的情况下按您预期的方式进行这项工作的唯一方法是使用 __new__ 而不是 __init__ （这样您就可以 return 由另一个构造函数创建的实例），并使用备用构造函数做一些糟糕的事情来显式调用顶部 class 的 __new__ 以避免循环调用依赖关系：

class Animal:
    def __new__(cls, name, legs):  # Use __new__ instead of __init__
        self = super().__new__(cls)  # Constructs base object
        self.legs = legs
        print(name)
        return self  # Returns initialized object
    @classmethod
    def with_two_legs(cls, name):
        # extremely long code to generate name_full from name
        name_full = name
        return Animal.__new__(cls, name_full, 2)  # Explicitly call Animal's __new__ using correct subclass

class Human(Animal):
    def __new__(cls):
        return super().with_two_legs('Human')  # Return result of alternate constructor

用 python 中的父类方法覆盖 init

Overriding init with parent classmethod in python

python

inheritance

constructor

class-method

用 python 中的父类方法覆盖 __init__

Overriding __init__ with parent classmethod in python

python

inheritance

constructor

class-method

用 python 中的父类方法覆盖 init

Overriding init with parent classmethod in python