Python中如何动态注解函数的对应Explicit子类返回类型？

现有类结构如下，包含Parent、Child1、Child2三类，每类又分Abstract、Explicit、Implicit三种风格：

from __future__ import annotations
import abc

###################################
# Parent classes
###################################
class AbstractParent(abc.ABC):
    @property
    @abc.abstractmethod
    def type_explicit(self) -> type[AbstractExplicitParent]:
        pass

class AbstractExplicitParent(AbstractParent):
    pass

class AbstractImplicitParent(AbstractParent):
    pass

###################################
# Child 1 classes
###################################
class AbstractChild1(AbstractParent):
    @property
    def type_explicit(self) -> type[ExplicitChild1]:
        return ExplicitChild1

class ExplicitChild1(AbstractExplicitParent, AbstractChild1):
    pass

class ImplicitChild1(AbstractImplicitParent, AbstractChild1):
    pass

###################################
# Child 2 classes
###################################
class AbstractChild2(AbstractParent):
    @property
    def type_explicit(self) -> type[ExplicitChild2]:
        return ExplicitChild2

class ExplicitChild2(AbstractExplicitParent, AbstractChild2):
    pass

class ImplicitChild2(AbstractImplicitParent, AbstractChild1):
    pass

当前定义的函数some_function仅能返回AbstractExplicitParent，无法精准表达“传入ImplicitChild1返回ExplicitChild1”这类类型关联：

def some_function(a: AbstractParent) -> AbstractExplicitParent:
    return a.type_explicit()  # 示例实现

需求是实现类似Explicit[T]的动态类型注解，让函数能精准推导返回类型：

T = TypeVar("T", bound=AbstractParent)
def some_function(a: T) -> Explicit[T]:
    ...

可以通过泛型协议定义AbstractParent子类与对应Explicit类的关联，无需复杂元类，同时调整type_explicit为类方法（比实例属性更适合类型推导）：

1. 调整type_explicit为类方法 #

将抽象属性改为抽象类方法，子类实现时直接返回对应Explicit类：

from __future__ import annotations
import abc
from typing import TypeVar, Protocol, Type

###################################
# 定义泛型协议与类型变量
###################################
T = TypeVar("T", bound="AbstractParent")
E = TypeVar("E", bound="AbstractExplicitParent")

class HasExplicitType(Protocol[T, E]):
    @classmethod
    @abc.abstractmethod
    def type_explicit(cls) -> Type[E]:
        pass

###################################
# Parent classes
###################################
class AbstractParent(abc.ABC, HasExplicitType["AbstractParent", "AbstractExplicitParent"]):
    @classmethod
    @abc.abstractmethod
    def type_explicit(cls) -> Type[AbstractExplicitParent]:
        pass

class AbstractExplicitParent(AbstractParent):
    pass

class AbstractImplicitParent(AbstractParent):
    pass

###################################
# Child 1 classes
###################################
class AbstractChild1(AbstractParent):
    @classmethod
    def type_explicit(cls) -> Type[ExplicitChild1]:
        return ExplicitChild1

class ExplicitChild1(AbstractExplicitParent, AbstractChild1):
    pass

class ImplicitChild1(AbstractImplicitParent, AbstractChild1):
    pass

###################################
# Child 2 classes
###################################
class AbstractChild2(AbstractParent):
    @classmethod
    def type_explicit(cls) -> Type[ExplicitChild2]:
        return ExplicitChild2

class ExplicitChild2(AbstractExplicitParent, AbstractChild2):
    pass

class ImplicitChild2(AbstractImplicitParent, AbstractChild1):
    pass

2. 定义Explicit类型别名与精准注解的函数 #

通过TypeVar绑定协议，实现Explicit[T]的动态类型推导：

from typing import TypeVar, TypeAlias

# 定义泛型类型别名，T绑定到HasExplicitType，提取其关联的E类型
T = TypeVar("T", bound=HasExplicitType)
Explicit: TypeAlias = TypeVar("Explicit", bound=AbstractExplicitParent)

def some_function(a: Type[T]) -> Type[Explicit]:
    return a.type_explicit()

# 类型推导验证
reveal_type(some_function(ImplicitChild1))  # 类型检查器会显示：Type[ExplicitChild1]
reveal_type(some_function(AbstractChild2)) # 类型检查器会显示：Type[ExplicitChild2]

3. 简化写法：用Protocol的Self类型（Python 3.11+） #

如果使用Python 3.11+，可以用typing.Self进一步简化，无需额外类型变量：

from typing import Self, Type, Protocol, abc

class HasExplicitType(Protocol):
    @classmethod
    @abc.abstractmethod
    def type_explicit(cls) -> Type[Self]:
        pass

# 调整AbstractParent实现
class AbstractParent(abc.ABC, HasExplicitType):
    @classmethod
    @abc.abstractmethod
    def type_explicit(cls) -> Type[AbstractExplicitParent]:
        pass

# 函数注解更简洁
T = TypeVar("T", bound=HasExplicitType)
def some_function(a: Type[T]) -> Type[T]:
    return a.type_explicit()

关键说明 #

• 泛型协议HasExplicitType用于定义“类必须返回对应Explicit子类”的契约，类型检查器可据此推导关联类型。
• 将type_explicit改为类方法，避免实例化依赖，同时更符合“返回类类型”的语义。
• 无需元类即可实现动态类型关联，类型检查器（如mypy、pyright）能精准识别传入类对应的返回类型。

内容的提问来源于stack exchange，提问作者Roy Smart