Вызвать несколько функций и вернуть коллективный результат

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.

Если вы составляете множество функций, то может стоить написать функцию 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 3

Лично две из моих любимых функций 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 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 )

все подклассы наследуются от базы. когда вы вызываете c.foo (arg), вы получите результат, переданный через все три метода _do_foo ().