使用 Python dict/set 记忆代数表达式

Question

我对将表达式存储在自引用类中很感兴趣，这些表达式可能会重复。我正在寻找一种方法的建议。我有几个想法。

例子：

a + b

现在由于加法是可交换的，如果我们认识到b + a 是同一个表达式就更好了。就我的申请而言，识别和折叠这些案例是可以的。

我一直在用这个做面条，想出了几种处理方法：

1) 使用set() 并为所有对象定义__hash__ 和__eq__，这将允许我唯一地定义表达式。一个优点是我可以很聪明并使用操作数的异或来简化检测交换情况：

class Expr(object):
    def __init__(self, op, left, right):
        self.op = op
        self.left = left
        self.right = right
    def __hash__(self):
        return hash(op) ^ hash(left) ^ hash(right)
    def __eq__(self, other):
        return self.op == other.op and \
            ((self.left == other.left and self.right == other.right) \
            or (self.left == other.right and self.right == other.left))

这样做的一个缺点是，为了测试给定的表达式是否已经存在，我需要构建一个对象来测试成员资格。如果已经在系列中，我只会丢弃它。

而且我相信，正如您所写的那样，__eq__ 函数会在您比较两棵树时引发完整的树遍历，这是您不想要的。理想情况下，记忆树的目的是简单的左/右指针值比较应该唯一地标识一个节点。

2) 使用 dict() 并使用要传递给构造函数的参数元组。为了处理交换操作，我可以为 ('+', 'a', 'b') 和 ('+', 'b', 'a') 安装密钥并将其分配给同一个对象。

key = ('+', left, right)
if key in mydict:
    expr = mydict[key]
else:
    expr = Expr('+', left, right)
    mydict[key] = expr
    mydict[('+', right, left)] = expr

return expr

我不能在这里使用 xor 方法，因为它不会产生保证唯一的密钥。

这里的事情变得有点更多有趣：

如果使用 set()/xor 方法，则可以检测关联相等。因此，(a + b) + c 和 a + (b + c) 可以如果您选择，则可以视为相同的表达式。

Answer 1

您可以通过缓存Expr 的实例来改进您的解决方案1，这样参数的顺序并不重要：

class CommutativeExpr(object):

    _instances = {}

    def __new__(cls, operator, left, right):
        key = (operator, frozenset([left, right]))
        try:
            return cls._instances[key]
        except KeyError:
            instance = cls._instances[key] = super().__new__(cls)
            return instance

    def __init__(self, operator, left, right):
        self.op = operator
        self.left = left
        self.right = right
        self._hash = hash((operator, frozenset([left, right])))

    def __hash__(self):
        return self._hash

    def __eq__(self, other):
        return self is other

这允许您使用身份检查来验证：

>>> CommutativeExpr('+', 'a', 'b') == CommutativeExpr('+', 'b', 'a')
True

这不支持“关联性”，但是您也可以通过正确定义 __hash__ 并让 __eq__ 进行更复杂的比较来添加该功能。

---

显然非交换表达式将需要不同的实现，这将是一个不同的类，或者您必须增加该类的复杂性以满足两种需求。