Python liskov替换原理及自定义init

Question

我正在编写带有提供异步初始化的自定义初始化函数的类。这一切都运行良好，除了当我创建子类并覆盖 async init 函数时，mypy 告诉我我违反了 liskov 替换原则。这给我留下了两个问题：

• 如何更改我的代码，以便 mypy 理解函数签名是故意不同的？与__init__类似。我的目标是使 ImplA 和 ImplB 尽可能简单，因为这些是我的用户实现的类。 AsyncInit 可能非常复杂。
• __init__ 是否违反了里氏替换原则？

from typing import TypeVar, Type, Any

TChild = TypeVar("TChild", bound="AsyncInit")


class AsyncInit:
    @classmethod
    async def new(cls: Type[TChild], *args: Any, **kwargs: Any) -> TChild:
        self = super().__new__(cls)
        await self.ainit(*args, **kwargs)  # type: ignore # ignore that TChild does not have `ainit` for now
        return self


class ImplA(AsyncInit):
    async def ainit(self, arg1: int, arg2: float) -> None:
        self.a = arg1
        self.b = arg2


class ImplB(ImplA):
    async def ainit(self, arg1: str, arg2: float, arg3: int) -> None:
        await super().ainit(arg2, arg3)
        self.c = arg1

Answer 1

LSP 通常不涵盖类的初始化，LSP 涉及实例的替换。根据 LSP 的定义：（强调我的）

子类型要求：设 phi(x) 是关于类型 T 的对象 x 的可证明属性。那么 phi(y) 对于 S 类型的对象 y 应该为真，其中 S 是 T 的子类型。

在 Python 的行话中，“T 类型的对象 x”是“T 的实例”。因此，LSP 不涵盖类型 T 本身的操作。具体来说，这意味着子类型之间的实例化不需要是可替换的。

因此，__new__ 和 __init__ 通常都被类型检查器免除子类型约束，因为它们的规范用法是在实例化期间。

---

对于通过 classmethod 替代构造函数来说，事情会更加棘手：可以在实例上调用 classmethod，并且通常。因此，classmethod 被视为实例行为的一部分，因此受到类型检查器的子类型约束。
这尤其适用于与常规方法无法区分的备用初始化器。

目前没有适当的方法来使初始化器类型化（例如通过对参数进行参数化），也没有具有同等可用性的替代设计（例如为该类型注册的外部构造函数）。
最简单的方法是实际告诉类型检查器该方法不是子类型约束的一部分。对于 MyPy，这是通过 # type:ignore [override] 完成的。

class ImplB(ImplA):
    async def ainit(self, arg1: str, arg2: float, arg3: int) -> None:  # type: ignore [override]
        await super().ainit(arg3, arg2)
        self.c = arg1

---

但是，通常值得考虑的是，跨子类型不可比较的替代 async 构造是否确实有意义：这意味着调用者已经具有 async > 能力（等待构造）并且无论如何都必须使用每个类的自定义代码（以提供特定参数）。
这意味着通常可以将整个async结构拉到调用者中。

Answer 2

错误消息是正确的 - 您实现的类要求调用者确切地知道他们正在操作的对象的类型（ImplA 与 ImplB），以便能够调用ainit，但是通过让一个从另一个派生，你暗示（或者，实际上，声明）他们不需要知道。

也许您真正需要的是 ImplA/ImplB 和 AsyncInit 之间的一个类，它知道如何完成 ainit< 中的常见工作/code> 在一个单独的方法中，然后两个派生类可以从它们的 ainit 方法中调用该方法。然后，ImplA 和 ImplB 都将从这个新类派生，而不是彼此派生。这样，ainit 就不是“重写”方法，并且可以具有不同的签名。

例如：

from typing import TypeVar, Type, Any

TChild = TypeVar("TChild", bound="AsyncInit")


class AsyncInit:
    @classmethod
    async def new(cls: Type[TChild], *args: Any, **kwargs: Any) -> TChild:
        self = super().__new__(cls)
        await self.ainit(*args, **kwargs)  # type: ignore # ignore that TChild does not have `ainit` for now
        return self


class NewBaseClass(AsyncInit):
    async def _ainit(self, arg1: int, arg2: float) -> None:
        self.a = arg1
        self.b = arg2


class ImplA(NewBaseClass):
    async def ainit(self, arg1: int, arg2: float) -> None:
        await super()._ainit(arg1, arg2)


class ImplB(NewBaseClass):
    async def ainit(self, arg1: str, arg2: float, arg3: int) -> None:
        await super()._ainit(arg3, arg2)
        self.c = arg1

我应该注意到，我已经从原始代码中翻转了 await super().ainit(arg2, arg3) 中参数的顺序，以便类型与被调用方法期望的类型匹配。