Skip to main content
 首页 » 编程设计

python之使用元类允许前向声明

2025年04月02日8zhenyulu

我想做一些绝对非 pythonic 的事情。我想创建一个允许对其类属性进行前向声明的类。 (如果你一定要知道,我正在尝试为解析器组合器制作一些甜美的语法。)

这就是我想要做的事情:

a = 1 
class MyClass(MyBaseClass): 
    b = a  # Refers to something outside the class 
    c = d + b  # Here's a forward declaration to 'd' 
    d = 1  # Declaration resolved 

我目前的方向是制作一个元类,以便在找不到 d 时捕获 NameError 异常并返回某个虚拟类的实例,我将调用 转发声明。我从 AutoEnum 中获得一些灵感,它使用元类魔术来声明带有裸标识符且没有赋值的枚举值。

以下是我目前所拥有的。缺少的部分是:如何继续正常的名称解析并捕获 NameError:

class MetaDict(dict): 
    def __init__(self): 
        self._forward_declarations = dict() 
    def __getitem__(self,  key): 
        try: 
            ### WHAT DO I PUT HERE ??? ### 
            # How do I continue name resolution to see if the 
            # name already exists is the scope of the class 
        except NameError: 
            if key in self._forward_declarations: 
                return self._forward_declarations[key] 
            else: 
                new_forward_declaration = ForwardDeclaration() 
                self._forward_declarations[key] = new_forward_declaration 
                return new_forward_declaration 
 
class MyMeta(type): 
    def __prepare__(mcs, name, bases): 
        return MetaDict() 
 
class MyBaseClass(metaclass=MyMeta): 
    pass 
 
class ForwardDeclaration: 
    # Minimal behavior 
    def __init__(self, value=0): 
        self.value = value 
    def __add__(self, other): 
        return ForwardDeclaration(self.value + other) 

请您参考如下方法:

开始于:

    def __getitem__(self,  key): 
        try: 
            return super().__getitem__(key) 
        except KeyError: 
             ... 

但这不允许您在类主体之外检索全局变量。 您还可以使用 __missin__ 方法,该方法专为 dict 的子类保留:

class MetaDict(dict): 
    def __init__(self): 
        self._forward_declarations = dict() 
 
    # Just leave __getitem__ as it is on "dict" 
    def __missing__(self,  key): 
        if key in self._forward_declarations: 
            return self._forward_declarations[key] 
        else: 
            new_forward_declaration = ForwardDeclaration() 
            self._forward_declarations[key] = new_forward_declaration 
            return new_forward_declaration 

如您所见,这不是“UnPythonic”——SymPy 和 SQLAlchemy 等高级 Python 东西必须求助于这种行为来发挥它们的魔力——只要确保对其进行了很好的记录和测试。

现在,为了允许使用全局(模块)变量,您必须稍微避开一点——可能还有一些在所有 Python 实现中都可能不可用的东西——即:内省(introspection)类主体所在的框架获取它的全局变量:

import sys 
... 
class MetaDict(dict): 
    def __init__(self): 
        self._forward_declarations = dict() 
 
    # Just leave __getitem__ as it is on "dict" 
    def __missing__(self,  key): 
        class_body_globals = sys._getframe().f_back.f_globals 
        if key in class_body_globals: 
             return class_body_globals[key] 
        if key in self._forward_declarations: 
            return self._forward_declarations[key] 
        else: 
            new_forward_declaration = ForwardDeclaration() 
            self._forward_declarations[key] = new_forward_declaration 
            return new_forward_declaration 

既然你在这里 - 你的特殊字典足以避免 NameErrors,但你的 ForwardDeclaration 对象还不够智能 - 在运行时:

a = 1 
class MyClass(MyBaseClass): 
    b = a  # Refers to something outside the class 
    c = d + b  # Here's a forward declaration to 'd' 
    d = 1  

发生的事情是 c 变成了一个 ForwardDeclaration 对象,但总和为 d 的即时值,即零。在下一行中,d 被值 1 简单地覆盖并且不再是惰性对象。所以你也可以声明 c = 0 + b 。

为了克服这个问题,ForwardDeclaration 必须是一个以智能方式设计的类,这样它的值总是被延迟计算,并且它的行为就像在“响应式(Reactive)编程”方法中一样:即:更新到一个值会将更新级联到依赖于它的所有其他值。我认为为您提供一个工作的“响应式(Reactive)”感知 FOrwardDeclaration 类的完整实现超出了这个问题的范围。 - 我在 github 上有一些玩具代码可以做到这一点 https://github.com/jsbueno/python-react , 不过。

即使使用适当的“Reactive”ForwardDeclaration 类,您也必须再次修复字典,以便 d = 1 类工作:

class MetaDict(dict): 
    def __init__(self): 
        self._forward_declarations = dict() 
 
    def __setitem__(self, key, value): 
        if key in self._forward_declarations: 
            self._forward_declations[key] = value 
            # Trigger your reactive update here if your approach is not 
            # automatic 
            return None 
         return super().__setitem__(key, value) 
    def __missing__(self,  key): 
        # as above 

最后,有一种方法可以避免 havign 实现完全响应式感知类 - 您可以在元类的 __new__ 方法上解决所有未决的 FOrwardDependencies -(这样您的 ForwardDeclaration 对象是手动的在类创建时“卡住”,不用担心 - )

一些东西:

from functools import reduce 
 
sentinel = object() 
class ForwardDeclaration: 
    # Minimal behavior 
    def __init__(self, value=sentinel, dependencies=None): 
        self.dependencies = dependencies or [] 
        self.value = value 
    def __add__(self, other): 
        if isinstance(other, ForwardDeclaration): 
             return ForwardDeclaration(dependencies=self.dependencies + [self]) 
        return ForwardDeclaration(self.value + other) 
 
class MyMeta(type): 
    def __new__(metacls, name, bases, attrs): 
         for key, value in list(attrs.items()): 
              if not isinstance(value, ForwardDeclaration): continue 
              if any(v.value is sentinel for v in value.dependencies): continue 
              attrs[key] = reduce(lambda a, b: a + b.value, value.dependencies, 0)  
 
         return super().__new__(metacls, name, bases, attrs) 
    def __prepare__(mcs, name, bases): 
        return MetaDict() 

并且,根据您的类层次结构和您具体在做什么,请记住还使用在其祖先上创建的 _forward_dependencies 更新一个类的字典 _forward_dependencies。 并且如果您需要 + 以外的任何运算符,正如您已经注意到的,您将必须保留有关运算符本身的信息 - 在这一点上,您不妨使用 sympy。