解决 Python 接口类中工厂方法创建属性的类型提示问题-Python教程-PHP中文网

解决 Python 接口类中工厂方法创建属性的类型提示问题

霞舞

发布： 2025-10-19 10:54:01

原创

272人浏览过

解决 python 接口类中工厂方法创建属性的类型提示问题

本文旨在解决在 Python 接口类中使用工厂方法动态创建属性时，类型提示丢失的问题。通过自定义泛型 `property` 类，并结合类型注解，可以确保动态生成的属性也能获得正确的类型提示，从而提高代码的可读性和可维护性。

在 Python 中，使用 property 装饰器可以方便地创建类的属性，隐藏 getter 和 setter 方法。然而，当需要动态创建具有相似结构的属性时，使用工厂方法是一种常见的代码复用手段。但这种方式会导致类型提示丢失，使得 IDE 和类型检查器无法正确识别属性的类型。本文将介绍如何解决这个问题，确保动态生成的属性也能获得正确的类型提示。

问题描述

假设我们有一个接口类 Interface，它使用工厂方法 property_factory 来创建属性 foo 和 bar。

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")
    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()

登录后复制

在这个例子中，Interface.foo 和 Interface.bar 的类型被推断为 Any，而不是预期的 str。这会导致类型检查器无法发现潜在的类型错误。

立即学习“Python免费学习笔记（深入）”；

解决方案：自定义泛型 Property 类

为了解决这个问题，我们可以自定义一个泛型 Property 类，继承自内置的 property 类，并使用 typing 模块中的 TypeVar 和 Generic 来实现泛型。

from typing import Any, Generic, TypeVar, overload, cast, Callable

T = TypeVar('T')  # The return type
I = TypeVar('I')  # The outer instance's type

class Property(property, Generic[I, T]):

    def __init__(
        self,
        fget: Callable[[I], T] | None = None,
        fset: Callable[[I, T], None] | None = None,
        fdel: Callable[[I], None] | None = None,
        doc: str | None = None
    ) -> None:
        super().__init__(fget, fset, fdel, doc)

    @overload
    def __get__(self, instance: None, owner: type[I] | None = None) -> Callable[[I], T]:
        ...

    @overload
    def __get__(self, instance: I, owner: type[I] | None = None) -> T:
        ...

    def __get__(self, instance: I | None, owner: type[I] | None = None) -> Callable[[I], T] | T:
        return cast(Callable[[I], T] | T, super().__get__(instance, owner))

    def __set__(self, instance: I, value: T) -> None:
        super().__set__(instance, value)

    def __delete__(self, instance: I) -> None:
        super().__delete__(instance)

登录后复制

这个 Property 类是一个泛型类，它接受两个类型参数：I 表示外部实例的类型，T 表示属性的返回类型。通过使用 Generic[I, T]，我们可以告诉类型检查器，这个 property 类是泛型的，并且它的行为取决于 I 和 T 的类型。

应用自定义 Property 类

现在，我们可以使用自定义的 Property 类来创建属性。首先，我们需要定义 getter 和 setter 函数的类型别名。

AI建筑知识问答

用人工智能ChatGPT帮你解答所有建筑问题

查看详情

from collections.abc import Callable

Getter = Callable[['Interface'], str]
Setter = Callable[['Interface', str], None]

def complex_property(name: str) -> tuple[Getter, Setter]:
    def _getter(self: Interface) -> str:
        ...

    def _setter(self: Interface, value: str) -> None:
        ...

    return _getter, _setter

登录后复制

然后，我们可以使用 Property 类来创建属性。

class Interface:

    foo = Property(*complex_property("foo"))

登录后复制

通过这种方式，类型检查器可以正确地推断出 Interface.foo 的类型为 str。

示例代码

以下是完整的示例代码：

from typing import Any, Generic, TypeVar, overload, cast, Callable
from collections.abc import Callable

T = TypeVar('T')  # The return type
I = TypeVar('I')  # The outer instance's type

class Property(property, Generic[I, T]):

    def __init__(
        self,
        fget: Callable[[I], T] | None = None,
        fset: Callable[[I, T], None] | None = None,
        fdel: Callable[[I], None] | None = None,
        doc: str | None = None
    ) -> None:
        super().__init__(fget, fset, fdel, doc)

    @overload
    def __get__(self, instance: None, owner: type[I] | None = None) -> Callable[[I], T]:
        ...

    @overload
    def __get__(self, instance: I, owner: type[I] | None = None) -> T:
        ...

    def __get__(self, instance: I | None, owner: type[I] | None = None) -> Callable[[I], T] | T:
        return cast(Callable[[I], T] | T, super().__get__(instance, owner))

    def __set__(self, instance: I, value: T) -> None:
        super().__set__(instance, value)

    def __delete__(self, instance: I) -> None:
        super().__delete__(instance)

Getter = Callable[['Interface'], str]
Setter = Callable[['Interface', str], None]

def complex_property(name: str) -> tuple[Getter, Setter]:
    def _getter(self: Interface) -> str:
        return name

    def _setter(self: Interface, value: str) -> None:
        pass

    return _getter, _setter

class Interface:

    foo = Property(*complex_property("foo"))

    @property
    def bar(self) -> str:
        return "bar"

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

instance = Interface()

reveal_type(Interface.foo)
reveal_type(Interface.bar)

reveal_type(instance.foo)
reveal_type(instance.bar)

instance.foo = 'lorem'
instance.bar = 'ipsum'

# instance.foo = 42 # Type Error
# instance.bar = 42 # Type Error

登录后复制