如何为工厂方法创建的Python类property添加正确的类型提示？

我在Python中实现了一个Interface类，用property封装getter/setter逻辑。因为多个属性结构相似，所以用工厂方法批量创建这些property，但类型检查工具（比如mypy、Pyright）把foo和bar识别成Any类型，而非正确的property[str, str]（即属性值类型为str）。直接写foo: str = property_factory("foo")会有误导性，因为foo本身是property对象，不是字符串。

原代码如下：

from __future__ import annotations


class Interface:

    def property_factory(name: str) -> property:
        """Create a property depending on the name."""

        @property
        def _complex_property(self: Interface) -> str:
            # Do something complex with the provided name
            return name

        @_complex_property.setter
        def _complex_property(self: Interface, _: str):
            pass

        return _complex_property

    foo = property_factory("foo")  # Works just like an actual property
    bar = property_factory("bar")


def main():
    interface = Interface()
    interface.foo  # Is of type '(variable) foo: Any' instead of '(property) foo: str'


if __name__ == "__main__":
    main()

下面是几种可行的解决方案：

方法1：用typing.cast明确标注Property类型 #

直接在赋值时用cast指定属性的实际类型，告诉类型检查工具这是一个返回str的property：

from typing import cast, property
from __future__ import annotations


class Interface:

    def property_factory(name: str) -> property:
        """Create a property depending on the name."""
        @property
        def _complex_property(self: Interface) -> str:
            return name

        @_complex_property.setter
        def _complex_property(self: Interface, _: str):
            pass

        return _complex_property

    foo: property[str, str] = cast(property[str, str], property_factory("foo"))
    bar: property[str, str] = cast(property[str, str], property_factory("bar"))

这样类型检查工具就能正确识别interface.foo的类型为str，同时也明确foo本身是property对象。

方法2：优化工厂函数的类型标注 #

给property_factory添加泛型类型提示，让类型检查工具能自动推断返回的property对应的类型：

from typing import TypeVar, property
from __future__ import annotations

T = TypeVar("T", bound=str)


class Interface:

    @staticmethod
    def property_factory(name: str) -> property[T, T]:
        """Create a property depending on the name."""
        @property
        def _complex_property(self: Interface) -> T:
            return name  # 实际返回str，T会被推断为str

        @_complex_property.setter
        def _complex_property(self: Interface, value: T):
            pass

        return _complex_property

    foo = Interface.property_factory("foo")
    bar = Interface.property_factory("bar")

这里把property_factory改成静态方法（因为它不需要访问实例），通过TypeVar标记property的类型参数，让类型检查工具能准确推断属性值的类型。

方法3：用Protocol定义属性接口 #

如果需要明确的接口约束，可以定义一个Protocol来描述属性的类型，再让Interface实现这个Protocol：

from typing import Protocol, property
from __future__ import annotations


class InterfaceProtocol(Protocol):
    @property
    def foo(self) -> str: ...
    @foo.setter
    def foo(self, value: str) -> None: ...

    @property
    def bar(self) -> str: ...
    @bar.setter
    def bar(self, value: str) -> None: ...


class Interface:
    def property_factory(name: str) -> property:
        @property
        def _complex_property(self: Interface) -> str:
            return name

        @_complex_property.setter
        def _complex_property(self: Interface, _: str):
            pass

        return _complex_property

    foo = property_factory("foo")
    bar = property_factory("bar")

# 类型检查工具会验证Interface是否符合InterfaceProtocol的定义
def use_interface(obj: InterfaceProtocol) -> None:
    print(obj.foo)
    obj.bar = "test"

这种方法适合需要严格接口契约的场景，确保Interface的属性完全符合预期的类型要求。

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