使用可调用类实现Python函数属性的类型注解

python中，直接在函数定义内部为附加到函数对象上的属性进行类型注解并不被标准类型检查器直接支持。本文将介绍一种有效的方法：通过构建一个可调用类作为装饰器来包装目标函数，从而在该类中定义并注解这些函数属性，实现类型安全的代码，并与静态类型检查工具良好集成。

在Python中，虽然我们可以通过PEP 232的定义为函数动态添加属性，并且通过PEP 484进行类型注解，但这两者结合起来，直接在函数内部对运行时动态添加的函数属性进行类型注解，是目前类型系统的一个挑战。例如，我们可能希望为函数添加一个缓存字典 foo.cache，并对其进行类型注解，但以下方式并不能直接获得类型检查器的支持：

def foo(s: str):
  # 如何在此处注解 foo.cache 的类型？
  try:
    print(foo.cache[s])
  except AttributeError: # 首次访问时可能抛出
    print('NEW')
    foo.cache = {} # 此时添加属性
    foo.cache[s] = 'CACHE' + s
  except KeyError:
    print('NEW')
    foo.cache[s] = 'CACHE' + s

# 在函数外部定义属性，类型检查器也无法在函数内部预知其类型
foo.cache = {} 

这种情况下，类型检查器（如MyPy）无法在函数 foo 内部静态地识别 foo.cache 的类型，从而无法提供类型安全保障。

解决方案：使用可调用类作为装饰器

为了解决这个问题，我们可以利用Python的可调用类（Callable Class）作为装饰器来包装目标函数。这种方法允许我们在类的定义中明确地声明并注解函数所需的附加属性，从而使得类型检查器能够正确地识别和验证这些属性。

实现步骤

1. 定义一个可调用类： 这个类将持有原始函数，并定义所有需要注解的函数属性。
2. 在类中注解属性： 使用标准的类型提示语法为这些属性提供类型信息。
3. 实现 __init__ 方法： 初始化这些属性，并将原始函数作为参数传入并保存。
4. 实现 __call__ 方法： 使类的实例能够像函数一样被调用，通常是委托给原始函数执行。
5. 将类作为装饰器应用： 使用 @ 语法将这个可调用类应用到目标函数上。

示例代码

以下是一个具体的示例，演示如何使用 Cacheable 类为 foo 函数的 cache 属性提供类型注解：

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

SpeakingPass-打造你的专属雅思口语语料

使用chatGPT帮你快速备考雅思口语，提升分数

25

查看详情

import typing

class Cacheable:
    """
    一个可调用类，用于为函数添加可缓存的属性，并进行类型注解。
    """
    cache: dict[str, str] # 注解 cache 属性为 str 到 str 的字典
    _call: typing.Callable[[str], None] # 注解 _call 属性为接收 str 返回 None 的可调用对象

    def __init__(self, call: typing.Callable[[str], None]) -> None:
        """
        初始化 Cacheable 实例。
        Args:
            call: 被装饰的原始函数。
        """
        self.cache = {} # 初始化 cache 字典
        self._call = call # 保存原始函数

    def __call__(self, s: str) -> None:
        """
        使 Cacheable 实例可像函数一样被调用，并执行原始函数的逻辑。
        Args:
            s: 原始函数接收的参数。
        """
        # 在这里执行原始函数的逻辑，可以通过 self 访问 cache
        try:
            print(self.cache[s]) # 访问并使用 cache
            # print(self.other_attribute[s]) # MyPy 会报错: "Cacheable" has no attribute "other_attribute"
        except KeyError:
            print('new')
            self.cache[s] = f'cache_{s}' # 更新 cache

        # 如果需要，也可以在此处调用原始函数
        # return self._call(s) 
        # 注意：在这个示例中，我们修改了 __call__ 来直接处理逻辑，
        # 如果原始函数有独立的逻辑，且需要执行，则应保留 self._call(s)
        # 例如：self._call(s)

# 使用 @Cacheable 装饰器应用到 foo 函数
@Cacheable
def foo(s: str) -> None:
    # 这里的函数体实际上不会直接执行，而是由 Cacheable.__call__ 代理
    # 但其签名用于初始化 Cacheable._call
    pass # 实际逻辑已转移到 Cacheable.__call__ 中

# foo.some_other_attribute = {} # MyPy 会报错: "Cacheable" has no attribute "some_other_attribute"

print("--- 第一次调用 ---")
foo('a') # 实际调用 Cacheable.__call__
print("--- 第二次调用 ---")
foo('a') # 再次调用，此时 cache 中已有 'a'
print("--- 第三次调用 ---")
foo('b') # 调用 'b'，cache 中没有，新增

代码解析

1. class Cacheable:：定义了一个名为 Cacheable 的类。
2. cache: dict[str, str]：在这里，我们明确地为 Cacheable 类实例添加了一个 cache 属性，并将其类型注解为 dict[str, str]。这是实现类型安全的关键。
3. _call: typing.Callable[[str], None]：这个属性用于保存被装饰的原始函数。它的类型注解表明它是一个接收一个 str 参数并返回 None 的可调用对象。
4. __init__(self, call: typing.Callable[[str], None]) -> None：构造函数在 Cacheable 实例被创建时执行。它初始化了 self.cache 为一个空字典，并将传入的原始函数 call 赋值给 self._call。
5. __call__(self, s: str) -> None：这个特殊方法使得 Cacheable 的实例可以像函数一样被调用。当 foo('a') 被执行时，实际上是调用了 Cacheable 实例的 __call__ 方法。在这个方法中，我们可以直接访问 self.cache 并执行原始函数的逻辑（或者像示例中那样，将逻辑直接放在 __call__ 中处理）。
6. @Cacheable：当 foo 函数被 @Cacheable 装饰时，Python 会执行 foo = Cacheable(foo)。这意味着 foo 不再是原始的函数对象，而是 Cacheable 类的一个实例。因此，当我们通过 foo.cache 访问时，实际上访问的是 Cacheable 实例的 cache 属性。

类型检查的优势

使用这种模式后，静态类型检查器（如MyPy）将能够识别 foo.cache 的类型，并在代码中对其进行验证。例如：

• 如果你尝试访问 foo.other_attribute 而 Cacheable 类中没有定义 other_attribute，MyPy 会报告一个错误，提示 Cacheable 没有这个属性。
• 如果你尝试将非字符串键或值存入 foo.cache，MyPy 也会根据 dict[str, str] 的注解发出警告。

这极大地增强了代码的健壮性和可维护性。

注意事项

1. 函数身份的变化： 经过装饰后，原始函数 foo 的身份发生了改变。它不再是一个函数对象，而是 Cacheable 类的一个实例。这意味着，如果你需要访问原始函数的元数据（如 __name__、__doc__），你需要通过 foo._call.__name__ 等方式来访问。
2. 逻辑封装： 示例中将缓存逻辑直接放到了 Cacheable.__call__ 中。如果原始函数 foo 本身有独立的业务逻辑需要执行，你应该在 __call__ 方法中显式地调用 self._call(s) 来执行原始函数的逻辑。
3. 通用性： 这种模式不仅限于缓存，还可以用于为函数添加任何需要类型注解的状态或行为，例如计数器、日志器等。

总结

尽管Python标准库没有直接提供在函数内部为动态属性进行类型注解的机制，但通过巧妙地利用可调用类作为装饰器，我们可以优雅地解决这一问题。这种方法不仅能够清晰地定义和注解函数属性的类型，还能与静态类型检查工具无缝集成，从而提高代码的质量和可维护性。它是一种在函数上附加类型化状态的强大且类型安全的设计模式。

以上就是使用可调用类实现Python函数属性的类型注解的详细内容，更多请关注php中文网其它相关文章！