python - 在python中返回值的类定义

Question

我已经定义了一个类

代码.py

class test:
     def __init__(self.x,self.y):
       self.x = x
       self.y = y


    def sum(self):
      z = self.x + self.y
      return z

def main():
   x = test(1,2)
   valsum = x.sum()

我希望在调用类而不是调用方法 id 时返回总和？

我将如何编码

Answer 1

为此使用一个函数：

def test(*args):
    return sum(args)

或者更好的是，只需使用内置：

sum((1,2))

---

如果你有充分的理由想要这个，你可以随时将这些东西包装在另一个函数中：

def testsum(a,b):
    t = test(a,b)
    return t.sum()

或者你可以这样做：

result = test(a,b).sum()

直接地。这应该谨慎使用，因为它效率低下......

---

最后（正如评论中所指出的，如果你覆盖__new__，你可以这样做，不要这样做）

class test(object):
    def __new__(cls,*args):
       return sum(*args)

print (test(1,2,3,4)) #10

Answer 2

您可以覆盖__new__()：

class test(object):
    def __new__(cls, x, y):
        return x+y

z = test(1, 2)
print z # => 3

也就是说，我不能强调这样做是多么令人难以置信，或多或少总是如此。

虽然我们毫无意义，但您也可以有sum()一个方法：

class test(object):
    def __new__(cls, *args, **kwargs):
        test_obj = super(test, cls).__new__(cls)
        test_obj.__init__(*args, **kwargs)
        return test_obj.sum()

    def __init__(self, x, y):
        test.x = x
        test.y = y

    def sum(self):
        return self.x + self.y

z = test(1, 2)
print z

但是，没有办法在__new__实现之外访问它。test或者不通过手动调用object.__new__()and来“艰难地”创建实例__init__，此时您在主管手中遭受的任何暴力都是合理的。

为了最大限度地变态，这是@kindall建议的变体——当然是不必要的过度设计：

使用元类

class meta_delegate(type):
    def __call__(cls, *args, **kwargs):
        obj = cls.__new__(cls)
        obj.__init__(*args, **kwargs)
        delegate = cls.__delegate
        if (isinstance(delegate, basestring)):
            delegate = getattr(obj, delegate)
            return delegate()
        else:
            return delegate(obj)

    @staticmethod
    def to(delegate):
        def __new__(*args, **kwargs):
            cls = meta_delegate(*args, **kwargs)
            cls.__delegate = delegate
            return cls
        return __new__

class test(object):
    def __init__(self, x, y):
        test.x = x
        test.y = y

    def sum(self):
        return self.x + self.y

    __metaclass__ = meta_delegate.to(sum)

我真的很惊讶它的工作原理。似乎调用元类不使用它的__call__.

最后一个只是为了说明这一切的毫无意义：

如此毫无意义，它是循环的

class meta_delegate(type):
    def __call__(cls, *args, **kwargs):
        return cls.__delegate(*args, **kwargs)

    @staticmethod
    def to(delegate):
        def __new__(*args, **kwargs):
            cls = meta_delegate(*args, **kwargs)
            cls.__delegate = staticmethod(delegate)
            return cls
        return __new__

class test(object):
    __metaclass__ = meta_delegate.to(lambda x, y: x+y)

这里的委托可以是任何可调用的，而且 API 更简单！现在，如果你能原谅我，我会去喝一杯。

Answer 3

虽然不可能从构造函数返回任何值，但您可以使用__call__魔法方法使您的对象直接可调用。

class Sum:
    def __init__(self, x, y):
        self.x = x
        self.y = y
    def __call__(self):
        return self.x + self.y

x = Sum(4,7)
x() # = 11