Question

我已经定义了一个类

code.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__()，无需创建__init__实例“艰难的方式”，此时您的主管手中的任何暴力都是合理的。< / p>

为了最大化变态，这里是@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

用于在python中返回值的类定义

3 个答案:

使用元类

毫无意义，这是圆形的