我想知道是否存在一个 python 模块可以让我做这样的事情:

x = MagicNumber()
x.value = 3
y = 2 * (x + 2) ** 2 - 8
print y   # 42
x.value = 2
print y   # 24

因此 MagicNumber 将实现所有特殊的运算符方法，并且它们都将返回 MagicNumber 的实例，同时跟踪执行了哪些操作。有这样的类吗？

编辑:澄清

我想在一个模块中使用它，该模块应该记住用户希望执行的一些任意计算的大量参数。所以用户将设置参数，然后使用它们来产生他的结果。然后，如果他决定要更改参数，更改会立即反射(reflect)在他的结果中。因此，只有一个参数实例的非常简化的使用 session 如下所示:

p = MyParams()
p.distance = 13.4           # I use __getattr__ and __setattr__ such that
p.speed = 3.14              # __getattr__ returns MagicNumber instances
time = p.distance / p.speed

编辑 2:更多说明

好吧，我会做我一开始就该做的事。我会提供上下文。

您是一名工程师，您要制作一份详细说明某些原型(prototype)小工具的工作原理和属性的 LaTeX 文档。这是您将针对不同原型(prototype)重复执行的任务。你写了一个小的 LaTeX python 界面。对于每个原型(prototype)，您创建一个 python 模块来生成必要的文档。在其中输入 LaTeX 代码，同时根据需要计算变量，以便计算是在上下文中进行的。一段时间后，您注意到两个问题:

1. 变量和参数的数量使本地化变得一团糟，变量名也很难记住。您应该将它们分组，以便对它们进行跟踪。
2. 有时您需要重做相同的计算，该计算分布在最后几章和十几行中，并且更改了一个或多个参数。您应该找到一些方法来避免代码重复。

从这个问题中得出原始问题。

最佳答案

是这样的吗？

import operator

MAKE_BINARY  = lambda opfn : lambda self,other : BinaryOp(self, asMagicNumber(other), opfn)
MAKE_RBINARY = lambda opfn : lambda self,other : BinaryOp(asMagicNumber(other), self, opfn)

class MagicNumber(object):
    __add__  = MAKE_BINARY(operator.add)
    __sub__  = MAKE_BINARY(operator.sub)
    __mul__  = MAKE_BINARY(operator.mul)
    __radd__ = MAKE_RBINARY(operator.add)
    __rsub__ = MAKE_RBINARY(operator.sub)
    __rmul__ = MAKE_RBINARY(operator.mul)
    # __div__  = MAKE_BINARY(operator.div)
    # __rdiv__ = MAKE_RBINARY(operator.div)
    __truediv__ = MAKE_BINARY(operator.truediv)
    __rtruediv__ = MAKE_RBINARY(operator.truediv)
    __floordiv__ = MAKE_BINARY(operator.floordiv)
    __rfloordiv__ = MAKE_RBINARY(operator.floordiv)

    def __neg__(self, other):
        return UnaryOp(self, lambda x : -x)

    @property
    def value(self):
        return self.eval()

class Constant(MagicNumber):
    def __init__(self, value):
        self.value_ = value

    def eval(self):
        return self.value_

class Parameter(Constant):
    def __init__(self):
        super(Parameter, self).__init__(0.0)

    def setValue(self, v):
        self.value_ = v

    value = property(fset=setValue, fget=lambda self: self.value_)

class BinaryOp(MagicNumber):
    def __init__(self, op1, op2, operation):
        self.op1 = op1
        self.op2 = op2
        self.opn = operation

    def eval(self):
        return self.opn(self.op1.eval(), self.op2.eval())


class UnaryOp(MagicNumber):
    def __init__(self, op1, operation):
        self.op1 = op1
        self.operation = operation

    def eval(self):
        return self.opn(self.op1.eval())

asMagicNumber = lambda x : x if isinstance(x, MagicNumber) else Constant(x)

这是实际操作:

x = Parameter()
# integer division
y = 2*x*x + 3*x - x//2

# or floating division
# y = 2*x*x + 3*x - x/2

x.value = 10
print(y.value)
# prints 225

x.value = 20
print(y.value)
# prints 850

# compute a series of x-y values for the function
print([(x.value, y.value) for x.value in range(5)])
# prints [(0, 0), (1, 5), (2, 13), (3, 26), (4, 42)]

关于能记住算术运算的类似 Python 数字的类？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/7820771/