返回函數的函數（在python中）

Question

是否可以創建一個將lambda函數作為參數的函數（每個lambda函數使用參數x ），然后返回一個具有單個參數x並返回所有lambda函數的乘積的新函數？

這是我的無效示例：

def func_you( lambdafunc1, lambdafunc2, lambdafunc3, lambdafunc4):
    return def func_you_2(x):
        return lambdafunc1(x) * lambdafunc2(x) * lambdafunc3(x) * lambdafunc4(x)

因此，實際上發生的是您有一個函數func_you ，它使用4個lambda函數，每個函數都使用參數x 。 例如， lambdafunc1的參數可能類似於lambda x: x + 10 。

然后func_you返回一個名為func_you_2的新函數，該函數的輸出是所有這些lambda函數的乘積，並且有一個參數x傳遞到func_you的每個lambda函數的x參數上。

假設我正在嘗試做的事情是可能的，我該如何傳達適當的語法來做到這一點？

另外，對於這種事情，是否有一個特定的名稱，而不是“返回函數的函數”？ 從技術上講，它不是嵌套函數，對嗎？

Answer 1

我的答案到目前為止沒有比其他任何答案更好的了，但是我想對其加以調整，以便從問題中擠出更多的功能編程汁液，只是為了好玩。

from functools import reduce
from operator import mul

def functioners(*funcs):
    def inner(x):
        return reduce(mul, [f(x) for f in funcs], 1)
    return inner

In [2]: res = functioners(lambda x: x+1, lambda x: x *2, lambda x: x+3)

In [3]: res(5)
Out[3]: 480

In [4]: res = functioners(lambda x: x+1, lambda x: x +1, lambda x: x+1)

In [5]: res(1)
Out[5]: 8

---

編輯

我什至有點瘋狂，以實現一種10分鍾的彎曲嘗試。 這不是我的同事可以接受的東西，但是現在很晚了，我可能只是為了好玩...

應該可以定義一個函數，該函數可以繼續返回自身的部分應用版本，但是我想您需要某種方法來告知它停止？

這是我的嘗試：

from functools import partial, reduce
from operator import mul

def functionals(*funcs, finished=None):
    def inner(x):
        return reduce(mul, [f(x) for f in funcs], 1)

    if finished is not None:
        # stop condition
        return inner
    else:
        return partial(functionals, *funcs)

您可以像這樣使用它（如果您如此傾向於...）

In [37]: f1 = functionals(lambda x: x+1)

In [38]: f2 = f1(lambda x: x + 1)

In [39]: f3 = f2(lambda x: x + 1, lambda x: x + 1, lambda x: x + 1)

In [40]: f3(finished="definitely!")(1)
Out[40]: 32

（我現在就拿帽子和外套...）

Answer 2

您可以返回執行所需功能的lambda函數。 范例-

def func_you( lambdafunc1, lambdafunc2, lambdafunc3, lambdafunc4):
    return lambda x: lambdafunc1(x) * lambdafunc2(x) * lambdafunc3(x) * lambdafunc4(x)

演示-

>>> def func_you( lambdafunc1, lambdafunc2, lambdafunc3, lambdafunc4):
...     return lambda x: lambdafunc1(x) * lambdafunc2(x) * lambdafunc3(x) * lambdafunc4(x)
...
>>> f = func_you(sum,min,max,sum)
>>> f([1,2])
18

Answer 3

從技術上講，這絕對是一個嵌套函數：

def func_you(lambdafunc1, lambdafunc2, lambdafunc3, lambdafunc4):
    def func_you_2(x):
        return lambdafunc1(x) * lambdafunc2(x) * lambdafunc3(x) * lambdafunc4(x)

    return func_you_2

但是您也可以使用lambda ：

def func_you(lambdafunc1, lambdafunc2, lambdafunc3, lambdafunc4):
    return lambda x: lambdafunc1(x) * lambdafunc2(x) * lambdafunc3(x) * lambdafunc4(x)

Answer 4

def in- def結構實際上很常見。 它用於實現裝飾器函數 ，該裝飾器函數將一個函數作為輸入，以某種方式對其進行修改，然后返回修改后的函數。 基本上，這種結構：

@decorator
def func(param):
    # stuff

是相同的：

def func(param):
    # stuff

func = decorator(func)

例如，假設您有幾個要修改的功能，以便它們在進入和退出時打印消息。 您編寫一個裝飾器函數：

def mark_entry_and_exit(func):
    def inner(*args, **kwargs):
        print "Entering function."
        try:
            result = func(*args, **kwargs)
        except:
            print "Exiting with exception."
            raise
        print "Exiting function."
        return result
    return inner

然后使用它，只需使用上面的@符號：

@mark_entry_and_exit
def my_function(a, b):
    print "Running with", a, b

my_function(1, b=2)

打印：

Entering function.
Running with 1 2
Exiting function.