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

Question

我想做一些绝对非 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)

Answer 1

开始于:

    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。