Question

我想将一些函数调用为单个值并返回集合结果。

class Foo:
    def __init__(self, i):
        self.i = i

    def get(self):
        return self.fn1(self.fn2(self.i)) #200

    def fn1(self, i):
        return i + i #10+10 = 20

    def fn2(self, i):
        return i * i #20*20 = 200

    #...

foo = Foo(10)
print(foo.get())

是否有更优雅的方式或模式？

Answer 1

这是我试图改善这一点。

def fn1(i):
    return i + i #10+10 = 20

def fn2(i):
    return i * i #20*20 = 200

def get(i):
    funcs = [fn2, fn1]
    for f in funcs:
        i = f(i)
    return i

print(get(10))

Answer 2

就个人而言，我最喜欢的两个python函数是map和reduce。

def get(i):
    return reduce(lambda acc, f: f(acc), [i,fn2,fn1] )

def fn1(i):
    return i + i #10+10 = 20

def fn2(i):
    return i * i #20*20 = 200

print( get(10) ) # 200

Answer 3

通常，上面的嵌套函数是在Python中组合函数的最简单易读的方法。

如果您正在编写许多函数，可能值得编写compose函数。

def compose(*funcs):
    if len(funcs) == 1:
        return funcs[0]
    else:
        def composition(*args, **kwargs):
            return funcs[0](compose(*funcs[1:])(*args, **kwargs))
        return composition

或者，如果您更喜欢迭代而不是递归解决方案：

def compose_pair(f1, f2):
    def composition(*args, **kwargs):
        return f1(f2(*args, **kwargs))
    return composition

def compose_iterative(*funcs):
    iterfuncs = iter(funcs)
    comp = next(iterfuncs)
    for f in iterfuncs:
        comp = compose_pair(comp, f)
    return comp

Answer 4

你可以使用装饰风格的解决方案：

class Base()

    def __init__(self, decorated):
       self.decorates = decorated

    def foo(self, arg):
        if self.decorates:
            arg = self.decorates.foo( arg )

        return self._do_foo( arg )

    def _do_foo(self, arg):
       return arg

您的实现将从Base继承并实现_do_foo（）。你这样设置：

a = Subclass(None)
b = AnotherSublcass( a )
c = YetAnotherSubclass( b )

所有Sublcasses都继承自Base。当你调用c.foo（arg）时，你会得到通过所有三个_do_foo（）方法的结果。

调用多个函数并返回集合结果

4 个答案: