如何在python中实现像sum(2)(3)(4)......(n)这样的函数？

Question

如何在python中实现一个会被调用的函数sum_numbers(2)(3)(4)......(n)?

结果应该是 2+3+4+.....+n

我得到的提示是，因为函数是 python 中的对象，所以有办法使用嵌套函数来完成这些操作，但我不确定。

def sum_number(x):
    def sum_number_2(y):
        def sum_number_3(z):
        ....................
            def sum_number_n(n)
                return n
            return sum_number_n
        return sum_number_3
    return sum_number_2
  return sum_number

但是我们应该能够在几个嵌套函数中完成它，而不是编写这么多嵌套函数来计算 n 个值的总和，当以以下方式调用时 sum_numbers(2)(3)(4)......(n)

Answer 1

如果您的函数正在 return 调用另一个函数，您不能只是将调用链接在一起并期望获得人类可读的结果。如果你想要一个函数在没有最终结果的情况下做你想做的事，这行得通：

def sum(x):
    def f(y):
        return sum(x+y)
    return f

如果您不介意打印出这些操作，您可以试试这个：

def sum(x):
    print(x)
    def f(y):
        return sum(x+y)
    return f

如果您绝对、绝对需要一个 return 值，那么您可以尝试这是一个肮脏、可怕的 hack：

def sum(x, v):
    v[0] = x
    def f(y, v):
        return sum(x+y, v)
    return f

v = [0]
sum(1,v)(2,v)(3,v)
print(v[0]) # Should return 6

这是另一个使用类的解决方案：

class sum(object):
    def __init__(self, x=0):
        self.x=x
    def __call__(self, *y):
        if len(y) > 0:
            self.x += y[0]
            return self
        return self.x

print(sum(1)(2)(3)()) # Prints 6

Answer 2

您要求的内容在 Python 中是不可能的，因为您没有提供确定调用链结束的方法，正如 cricket_007 在评论中提到的那样。但是，如果您 do 提供一种方法来指示没有更多的调用，那么该函数就很容易编写代码。指示链结束的一种方法是不带参数进行最后一次调用。

我在我的代码中使用 rsum（递归求和）作为函数的名称，因为 sum 是一个内置函数并且不必要地隐藏了 Python 内置 - ins 不是一个好的编码习惯：它可能使代码混乱，或者至少更难阅读，因为你必须记住这个名字不是指你通常期望的名字参考，并可能导致细微的错误。

def rsum(val=None, tot=0):
    if val is None:
        return tot
    tot += val
    return lambda val=None, tot=tot: rsum(val, tot)

print rsum(42)()
print rsum(1)(2)()
print rsum(4)(3)(2)(1)()
print rsum(4100)(310000)(9)(50)()

输出

Answer 3

使用 Python 的数据模型功能将结果转换为所需的类型。

class sum_number(object):
  def __init__(self, val):
    self.val = val

  def __call__(self, val):
    self.val += val
    return self

  def __float__(self):
    return float(self.val)

  def __int__(self):
    return int(self.val)

print '{}'.format(int(sum_number(2)(3)(8)))
print '{}'.format(float(sum_number(2)(3)(8)))

Answer 4

class MetaSum(type):

    def __repr__(cls):

            sum_str = str(cls.sum)

            cls.sum = 0

            return sum_str

    def __call__(cls, *args):

            for arg in args:

                    cls.sum += arg

            return cls



class sum_numbers(object, metaclass = MetaSum):
    sum = 0

print (sum_numbers(2)(3)(4)) # this only works in python 3

Answer 5

您可以创建可调用的 int 的子类：

class sum_numbers (int):
    def __new__ (cls, *args, **kwargs):
        return super().__new__(cls, *args, **kwargs)

    def __call__ (self, val):
        return sum_numbers(self + val)

这样，您就可以与普通整数完全兼容（因为 类型的对象是 普通整数），因此以下示例有效：

>>> sum_numbers(2)(3)(4)(5)
14
>>> isinstance(sum_numbers(2)(3), int)
True
>>> sum_numbers(2)(3) + 4
9

当然，您可能想要覆盖其他方法，例如__add__ 这样添加一个普通整数仍然会 return 您的类型的对象。否则，您将不得不使用结果调用类型，例如：

>>> sum_numbers(sum_numbers(2)(3) + 5)(6)
16

如何在python中实现像sum(2)(3)(4)......(n)这样的函数？

how to implement a function like sum(2)(3)(4)......(n) in python?

python

functional-programming

higher-order-functions