我有一个函数数组，我正在尝试生成一个函数，该函数由我的数组中的元素组成。 我的方法是：
def compose(list):
if len(list) == 1:
return lambda x:list[0](x)
list.reverse()
final=lambda x:x
for f in list:
final=lambda x:f(final(x))
return final
此方法似乎不起作用，将不胜感激。
（我正在颠倒列表，因为这是我想要函数的组合顺序）
答案 0 :(得分：25)
最简单的方法是首先编写2个函数的组合：
def compose2(f, g):
return lambda *a, **kw: f(g(*a, **kw))
然后使用reduce撰写更多功能：
def compose(*fs):
return reduce(compose2, fs)
或者您可以使用some library已经包含compose功能。
答案 1 :(得分：15)
def compose (*functions):
def inner(arg):
for f in reversed(functions):
arg = f(arg)
return arg
return inner
示例：
>>> def square (x):
return x ** 2
>>> def increment (x):
return x + 1
>>> def half (x):
return x / 2
>>> composed = compose(square, increment, half) # square(increment(half(x)))
>>> composed(5) # square(increment(half(5))) = square(increment(2.5)) = square(3.5) = 12,25
12.25
答案 2 :(得分：10)
它不起作用，因为您在循环中创建的所有匿名函数都引用相同的循环变量，因此共享其最终值。
作为快速解决方法，您可以将作业替换为：
final = lambda x, f=f, final=final: f(final(x))
或者，您可以从函数返回lambda：
def wrap(accum, f):
return lambda x: f(accum(x))
...
final = wrap(final, f)
要了解正在发生的事情，请尝试以下实验：
>>> l = [lambda: n for n in xrange(10)]
>>> [f() for f in l]
[9, 9, 9, 9, 9, 9, 9, 9, 9, 9]
这个结果令许多人感到惊讶，他们期望结果为[0, 1, 2, ...]。但是，所有lambda指向相同的n变量，并且都引用它的最终值，即9。在您的情况下，应该嵌套的final的所有版本最终引用相同的f，更糟糕的是final。
Python中lambdas和for循环的主题是already covered on SO。
答案 3 :(得分：8)
这是一个相当优雅的递归实现，为了清晰起见使用了Python 3的功能：
def strict_compose(*funcs):
*funcs, penultimate, last = funcs
if funcs:
penultimate = strict_compose(*funcs, penultimate)
return lambda *args, **kwargs: penultimate(last(*args, **kwargs))
Python 2兼容版本：
def strict_compose2(*funcs):
if len(funcs) > 2:
penultimate = strict_compose2(*funcs[:-1])
else:
penultimate = funcs[-2]
return lambda *args, **kwargs: penultimate(funcs[-1](*args, **kwargs))
这是一个使用延迟评估递归的早期版本：
def lazy_recursive_compose(*funcs):
def inner(*args, _funcs=funcs, **kwargs):
if len(_funcs) > 1:
return inner(_funcs[-1](*args, **kwargs), _funcs=_funcs[:-1])
else:
return _funcs[0](*args, **kwargs)
return inner
两者似乎都会在每次递归调用时创建一个新的元组和参数的字典。
让我们测试其中的一些实现并确定哪些是最高性能的，首先是一些单个参数函数（谢谢你戳）：
def square(x):
return x ** 2
def increment(x):
return x + 1
def half(x):
return x / 2
这里是我们的实现，我怀疑我的迭代版本是第二高效的（手动编写自然会最快），但这可能部分是由于它避免了传递任意数量的参数或关键字的困难函数之间的参数 - 在大多数情况下，我们只会看到传递的普通参数。
from functools import reduce
def strict_recursive_compose(*funcs):
*funcs, penultimate, last = funcs
if funcs:
penultimate = strict_recursive_compose(*funcs, penultimate)
return lambda *args, **kwargs: penultimate(last(*args, **kwargs))
def strict_recursive_compose2(*funcs):
if len(funcs) > 2:
penultimate = strict_recursive_compose2(*funcs[:-1])
else:
penultimate = funcs[-2]
return lambda *args, **kwargs: penultimate(funcs[-1](*args, **kwargs))
def lazy_recursive_compose(*funcs):
def inner(*args, _funcs=funcs, **kwargs):
if len(_funcs) > 1:
return inner(_funcs[-1](*args, **kwargs), _funcs=_funcs[:-1])
else:
return _funcs[0](*args, **kwargs)
return inner
def iterative_compose(*functions):
"""my implementation, only accepts one argument."""
def inner(arg):
for f in reversed(functions):
arg = f(arg)
return arg
return inner
def _compose2(f, g):
return lambda *a, **kw: f(g(*a, **kw))
def reduce_compose1(*fs):
return reduce(_compose2, fs)
def reduce_compose2(*funcs):
"""bug fixed - added reversed()"""
return lambda x: reduce(lambda acc, f: f(acc), reversed(funcs), x)
并测试这些：
import timeit
def manual_compose(n):
return square(increment(half(n)))
composes = (strict_recursive_compose, strict_recursive_compose2,
lazy_recursive_compose, iterative_compose,
reduce_compose1, reduce_compose2)
print('manual compose', min(timeit.repeat(lambda: manual_compose(5))), manual_compose(5))
for compose in composes:
fn = compose(square, increment, half)
result = min(timeit.repeat(lambda: fn(5)))
print(compose.__name__, result, fn(5))
我们得到以下输出（Python 2和3中的相同幅度和比例）：
manual compose 0.4963762479601428 12.25
strict_recursive_compose 0.6564744340721518 12.25
strict_recursive_compose2 0.7216697579715401 12.25
lazy_recursive_compose 1.260614730999805 12.25
iterative_compose 0.614982972969301 12.25
reduce_compose1 0.6768529079854488 12.25
reduce_compose2 0.9890829260693863 12.25
我的期望得到了确认：当然，最快的是手动功能组合，然后是迭代实现。懒惰的递归版本要慢得多 - 可能是因为每个函数调用都会创建一个新的堆栈帧，并为每个函数创建一个新的函数元组。
要获得更好，也许更真实的比较，如果您删除**kwargs并将*args更改为arg，那么使用它们的效果会更高，我们可以更好地比较苹果和苹果 - 在这里，除了手动组合，reduce_compose1胜出后跟strict_recursive_compose：
manual compose 0.443808660027571 12.25
strict_recursive_compose 0.5409777010791004 12.25
strict_recursive_compose2 0.5698030130006373 12.25
lazy_recursive_compose 1.0381018499610946 12.25
iterative_compose 0.619289995986037 12.25
reduce_compose1 0.49532539502251893 12.25
reduce_compose2 0.9633988010464236 12.25
只有一个arg的函数：
def strict_recursive_compose(*funcs):
*funcs, penultimate, last = funcs
if funcs:
penultimate = strict_recursive_compose(*funcs, penultimate)
return lambda arg: penultimate(last(arg))
def strict_recursive_compose2(*funcs):
if len(funcs) > 2:
penultimate = strict_recursive_compose2(*funcs[:-1])
else:
penultimate = funcs[-2]
return lambda arg: penultimate(funcs[-1](arg))
def lazy_recursive_compose(*funcs):
def inner(arg, _funcs=funcs):
if len(_funcs) > 1:
return inner(_funcs[-1](arg), _funcs=_funcs[:-1])
else:
return _funcs[0](arg)
return inner
def iterative_compose(*functions):
"""my implementation, only accepts one argument."""
def inner(arg):
for f in reversed(functions):
arg = f(arg)
return arg
return inner
def _compose2(f, g):
return lambda arg: f(g(arg))
def reduce_compose1(*fs):
return reduce(_compose2, fs)
def reduce_compose2(*funcs):
"""bug fixed - added reversed()"""
return lambda x: reduce(lambda acc, f: f(acc), reversed(funcs), x)
答案 4 :(得分：7)
一个班轮：
compose = lambda *F: reduce(lambda f, g: lambda x: f(g(x)), F)
使用示例：
f1 = lambda x: x+3
f2 = lambda x: x*2
f3 = lambda x: x-1
g = compose(f1, f2, f3)
assert(g(7) == 15)
答案 5 :(得分：3)
您还可以创建一系列函数并使用reduce：
def f1(x): return x+1
def f2(x): return x+2
def f3(x): return x+3
x = 5
# Will print f3(f2(f1(x)))
print reduce(lambda acc, x: x(acc), [f1, f2, f3], x)
# As a function:
def compose(*funcs):
return lambda x: reduce(lambda acc, f: f(acc), funcs, x)
f = compose(f1, f2, f3)
答案 6 :(得分：2)
pip install funcoperators是另一个实现它的库，该库允许使用中缀符号：
from funcoperators import compose
# display = lambda x: hex(ord(list(x)))
display = hex *compose* ord *compose* list
# also works as a function
display = compose(hex, ord, list)
pip安装funcoperators https://pypi.org/project/funcoperators/
免责声明：我是模块的创建者
答案 7 :(得分：1)
我发现的最可靠的实现是在第三方库toolz中。此库中的compose函数还处理函数组合的docstring。
source code免费提供。以下是一个简单的使用示例。
from toolz import compose
def f(x):
return x+1
def g(x):
return x*2
def h(x):
return x+3
res = compose(f, g, h)(5) # 17
答案 8 :(得分：0)
这是我的版本
def compose(*fargs):
def inner(arg):
if not arg:
raise ValueError("Invalid argument")
if not all([callable(f) for f in fargs]):
raise TypeError("Function is not callable")
return reduce(lambda arg, func: func(arg), fargs, arg)
return inner
如何使用
的示例def calcMean(iterable):
return sum(iterable) / len(iterable)
def formatMean(mean):
return round(float(mean), 2)
def adder(val, value):
return val + value
def isEven(val):
return val % 2 == 0
if __name__ == '__main__':
# Ex1
rand_range = [random.randint(0, 10000) for x in range(0, 10000)]
isRandIntEven = compose(calcMean, formatMean,
partial(adder, value=0), math.floor.__call__, isEven)
print(isRandIntEven(rand_range))
答案 9 :(得分：0)
从我的角度（Imanol Luengo）看python notebook example的更一般的解决方案：
from functools import reduce
from functools import partial
def f(*argv, **kwargs):
print('f: {} {}'.format(argv, kwargs))
return argv, kwargs
def g(*argv, **kwargs):
print('g: {} {}'.format(argv, kwargs))
return argv, kwargs
def compose(fs, *argv, **kwargs):
return reduce(lambda x, y: y(*x[0], **x[1]), fs, (argv, kwargs))
h = partial(compose, [f, g])
h('value', key='value')
output:
f: ('value',) {'key': 'value'}
g: ('value',) {'key': 'value'}
m = partial(compose, [h, f, g])
m('value', key='value')
output:
f: ('value',) {'key': 'value'}
g: ('value',) {'key': 'value'}
f: ('value',) {'key': 'value'}
g: ('value',) {'key': 'value'}
答案 10 :(得分：0)
假设您具有以下功能：
def square(x):
return x**2
def inc(x):
return x+1
def half(x):
return x/2
如下定义组合函数：
import functools
def compose(*functions):
return functools.reduce(lambda f, g: lambda x: g(f(x)),
functions,
lambda x: x)
用法：
composed = compose(square, inc, inc, half)
compose(10)
>>> 51.0
以定义的顺序依次执行功能：
改编自https://mathieularose.com/function-composition-in-python/。
答案 11 :(得分：0)
由于可读性/简单性，我更喜欢这一点
from functools import reduce
def compose(*fs):
apply = lambda arg, f: f(arg)
composition = lambda x: reduce(apply, [x, *fs])
return composition
pipe = compose(a, b, c)将首先应用a，然后应用b，然后应用c。
关于可维护性（调试），我认为实际上这是最容易使用的：
def compose(*fs):
def composition(x):
for f in fs:
x = f(x)
return x
return composition
答案 12 :(得分：0)
我从 GeeksforGeeks here 找到了这段代码，用于 Python 3。不确定它的效率如何，但很容易理解。
# importing reduce() from functools
from functools import reduce
# composite_function accepts N
# number of function as an
# argument and then compose them
def composite_function(*func):
def compose(f, g):
return lambda x : f(g(x))
return reduce(compose, func, lambda x : x)
# Function to add 2
def add(x):
return x + 2
# Function to multiply 2
def multiply(x):
return x * 2
# Function to subtract 2
def subtract(x):
return x - 1
# Here add_subtract_multiply will
# store lambda x : multiply(subtract(add(x)))
add_subtract_multiply = composite_function(multiply,
subtract,
add)
print("Adding 2 to 5, then subtracting 1 and multiplying the result with 2: ",
add_subtract_multiply(5))
您可以继续向复合函数添加更多函数，例如：
print(composite_function(multiply, add, subtract, multiply,subtract, add)(5))
答案 13 :(得分：0)
非常好的问题，但答案肯定是不必要的复杂。只是：
def compose(*funs):
return (lambda x:
x if len(funs) == 0
else compose(*funs[:-1])(funs[-1](x)))