Question

我正在编写一个python程序，我需要重载＆gt;＆gt;运营商。我面临的问题是这个运算符需要是正确的关联。所以，如果我做以下

A >> B >> C >> D >> E

我希望将其解析为

(A >> (B >> (C >> (D >> E))))

根据我的理解，在python中这个运算符是关联的，所以我会得到，

((((A >> B) >> C) >> D) >> E)

当你进行运算符重载时，有没有改变python中运算符的默认关联性？

Answer 1

这可以做到......但需要付出一些努力。基本思想是使用右移运算符来创建和更新推迟实际计算的新类型对象。

例如，假设上面的变量：A，B，C，D和E都是Actual类型的对象。我们将介绍一个新类Deferred，它是由一个实例的实例上的rshift操作产生的。 Deferred还实现了rshift运算符，它更新对象并返回自身。

（顺便说一下，对于这个答案的其余部分，我假设A，B，C，D和E是不可变的，并且rshift操作产生一个新对象。）

F = A >> B >> C >> D >> E

会像......一样计算。

F = Deferred(A,B) >> C >> D >> E
F = Deferred(A,B,C) >> D >> E
F = Deferred(A,B,C,D) >> E
F = Deferred(A,B,C,D,E)

F维护一个缓存的实例，它是从反向序列计算的。此外，F实现与Actual相同的接口，因此在Deferred实例上调用的方法被委托给Actual的缓存实例。

我不知道你正在做的计算类型，所以在下面的例子中，我构成了一些微不足道的东西，只是为了证明延迟计算实际执行的时间，它们是相反的。

class Var(object):
    def __init__(self):
        pass

    @property
    def name(self):
        return self._name( )

    @property
    def length(self):
        return len(self.name)


class Actual(Var):
    def __init__(self, name):
        Var.__init__(self)
        self._text = name

    def _name(self):
        return self._text

    def __rshift__(self, other):
        if isinstance(other, Actual):
            return Deferred(self, other)

        return len(self.name)

    @staticmethod
    def NewFromShiftComputation(sequence):
        x = ' >> '.join(reversed(map(lambda actual: actual.name, sequence)))
        return Actual(x)



class Deferred(Var):
    def __init__(self, *args):
        Var.__init__(self)

        self._items  = [ ]
        self._actual = None  #-- cached "actual"

        for item in args:
            self._items.append(item)

    def _name(self):
        self._assure_actual( )
        return self._actual.name

    def __rshift__(self, other):
        self._actual = None  #-- Invalidate the cached "actual"
        self._items.append(other)
        return self

    def _assure_actual(self):
        if self._actual is None:
            self._actual = Actual.NewFromShiftComputation(self._items)



A = Actual('A')
B = Actual('B')
C = Actual('C')
D = Actual('D')
E = Actual('E')

F = A >> B >> C >> D >> E

print F.name
print F.length

Answer 2

这不是运营商的问题。 Python从左到右评估：
http://docs.python.org/reference/expressions.html#evaluation-order

因此，在这种情况下需要括号，因为它的所有操作符都相同。

Python运算符重载和运算符关联性

2 个答案: