Python Can'；t图此函数的组成代码

我编写了一个代码，可以得到n个函数并将它们组合在一起。如果函数没有收到任何输入，它将返回我们称为lambda函数的“x”。（示例-compose（）（3）#将返回3） 这是我的代码，我根本看不出问题：

def compose(*funcs):
    if len(funcs)==0:
        return lambda x: x
    else:
        for i in funcs[-1:0:-1]:

            return lambda x: funcs[0](funcs[i](x))

---

我想你说的是

def fn1(x):
    return x+1
def fn2(x):
    return x**2
def fn3(x):
    return math.sin(x)**0.5

def apply(my_list_of_stuff):
    if len(my_list_of_stuff) == 1:
         return my_list_of_stuff[0]
    return my_list_of_stuff[0](apply(my_list_of_stuff[1:]))

apply([fn1,fn2,fn3,7]) # -> fn1(fn2(fn3(7)))

---

假设我理解你的要求

我想你在说什么

def fn1(x):
    return x+1
def fn2(x):
    return x**2
def fn3(x):
    return math.sin(x)**0.5

def apply(my_list_of_stuff):
    if len(my_list_of_stuff) == 1:
         return my_list_of_stuff[0]
    return my_list_of_stuff[0](apply(my_list_of_stuff[1:]))

apply([fn1,fn2,fn3,7]) # -> fn1(fn2(fn3(7)))

---

假设我理解你的要求

我想你在说什么

def fn1(x):
    return x+1
def fn2(x):
    return x**2
def fn3(x):
    return math.sin(x)**0.5

def apply(my_list_of_stuff):
    if len(my_list_of_stuff) == 1:
         return my_list_of_stuff[0]
    return my_list_of_stuff[0](apply(my_list_of_stuff[1:]))

apply([fn1,fn2,fn3,7]) # -> fn1(fn2(fn3(7)))

---

假设我理解你的要求

我想你在说什么

def fn1(x):
    return x+1
def fn2(x):
    return x**2
def fn3(x):
    return math.sin(x)**0.5

def apply(my_list_of_stuff):
    if len(my_list_of_stuff) == 1:
         return my_list_of_stuff[0]
    return my_list_of_stuff[0](apply(my_list_of_stuff[1:]))

apply([fn1,fn2,fn3,7]) # -> fn1(fn2(fn3(7)))

---

假设我理解了您的要求

假设您有三个功能：

def f1(x):
    return 'f1 %s' % x

def f2(x):
    return 'f2 %s' % x

def f3(x):
    return 'f3 %s' % x

然后我们有一个函数compose：

def compose(*funcs):
    def f(x):
        ret = x
        for func in funcs[::-1]:
            ret = func(ret)
        return ret
    return f

我们可以这样使用它：

F = compose(f1, f2, f3)
print F('x')

它将打印出：

f1 f2 f3 x

---

希望这就是您想要的。

假设您有三个功能：

def f1(x):
    return 'f1 %s' % x

def f2(x):
    return 'f2 %s' % x

def f3(x):
    return 'f3 %s' % x

然后我们有一个函数compose：

def compose(*funcs):
    def f(x):
        ret = x
        for func in funcs[::-1]:
            ret = func(ret)
        return ret
    return f

我们可以这样使用它：

F = compose(f1, f2, f3)
print F('x')

它将打印出：

f1 f2 f3 x

---

希望这就是您想要的。

假设您有三个功能：

def f1(x):
    return 'f1 %s' % x

def f2(x):
    return 'f2 %s' % x

def f3(x):
    return 'f3 %s' % x

然后我们有一个函数compose：

def compose(*funcs):
    def f(x):
        ret = x
        for func in funcs[::-1]:
            ret = func(ret)
        return ret
    return f

我们可以这样使用它：

F = compose(f1, f2, f3)
print F('x')

它将打印出：

f1 f2 f3 x

---

希望这就是您想要的。

假设您有三个功能：

def f1(x):
    return 'f1 %s' % x

def f2(x):
    return 'f2 %s' % x

def f3(x):
    return 'f3 %s' % x

然后我们有一个函数compose：

def compose(*funcs):
    def f(x):
        ret = x
        for func in funcs[::-1]:
            ret = func(ret)
        return ret
    return f

我们可以这样使用它：

F = compose(f1, f2, f3)
print F('x')

它将打印出：

f1 f2 f3 x

---

希望这是您想要的。

使用可以优雅地实现函数合成。您也可以使用initializer参数实现无输入条件：

import functools

def compose(*funcs):
    return functools.reduce(lambda f, g: lambda x: f(g(x)), funcs, lambda x: x)

---

功能组合可以通过以下方式优雅地实现：。您也可以使用initializer参数实现无输入条件：

import functools

def compose(*funcs):
    return functools.reduce(lambda f, g: lambda x: f(g(x)), funcs, lambda x: x)

---

功能组合可以通过以下方式优雅地实现：。您也可以使用initializer参数实现无输入条件：

import functools

def compose(*funcs):
    return functools.reduce(lambda f, g: lambda x: f(g(x)), funcs, lambda x: x)

---

功能组合可以通过以下方式优雅地实现：。您也可以使用initializer参数实现无输入条件：

import functools

def compose(*funcs):
    return functools.reduce(lambda f, g: lambda x: f(g(x)), funcs, lambda x: x)

---

我认为更好的方法是：

def compose(*funcs):
    chain = lambda f, g: lambda *a, **kw: f(g(*a, **kw))
    return reduce(chain, funcs, lambda x: x)

它将返回一个新函数，该函数是传递给它的函数列表的组成部分。如果您不关心kwargs，您可以：

def compose(*funcs):
    chain = lambda f, g: lambda *a: f(g(*a))
    return reduce(chain, funcs, lambda x: x)

例如：

>>> def compose(*funcs):
...     chain = lambda f, g: lambda *a: f(g(*a))
...     return reduce(chain, funcs, lambda x: x)
...
>>> remove_newlines = compose(lambda l: "".join(l), lambda s: s.split("\n"))
>>> remove_newlines("hello\n world")
'hello world'

---

注意：在python3中，reduce已经从stdlib移到functools中，因此您需要从functools import reduce执行

，我认为更好的实现方法是：

def compose(*funcs):
    chain = lambda f, g: lambda *a, **kw: f(g(*a, **kw))
    return reduce(chain, funcs, lambda x: x)

它将返回一个新函数，该函数是传递给它的函数列表的组成部分。如果您不关心kwargs，您可以：

def compose(*funcs):
    chain = lambda f, g: lambda *a: f(g(*a))
    return reduce(chain, funcs, lambda x: x)

例如：

>>> def compose(*funcs):
...     chain = lambda f, g: lambda *a: f(g(*a))
...     return reduce(chain, funcs, lambda x: x)
...
>>> remove_newlines = compose(lambda l: "".join(l), lambda s: s.split("\n"))
>>> remove_newlines("hello\n world")
'hello world'

注意：在python3中，reduce已经从stdlib移到functools中，因此您需要从functools import reduce执行
，我认为更好的实现方法是：

def compose(*funcs):
    chain = lambda f, g: lambda *a, **kw: f(g(*a, **kw))
    return reduce(chain, funcs, lambda x: x)

它将返回一个新函数，该函数是传递给它的函数列表的组成部分。如果您不关心kwargs，您可以：

def compose(*funcs):
    chain = lambda f, g: lambda *a: f(g(*a))
    return reduce(chain, funcs, lambda x: x)

例如：

>>> def compose(*funcs):
...     chain = lambda f, g: lambda *a: f(g(*a))
...     return reduce(chain, funcs, lambda x: x)
...
>>> remove_newlines = compose(lambda l: "".join(l), lambda s: s.split("\n"))
>>> remove_newlines("hello\n world")
'hello world'

注意：在python3中，reduce已经从stdlib移到functools中，因此您需要从functools import reduce执行
，我认为更好的实现方法是：

def compose(*funcs):
    chain = lambda f, g: lambda *a, **kw: f(g(*a, **kw))
    return reduce(chain, funcs, lambda x: x)

它将返回一个新函数，该函数是传递给它的函数列表的组成部分。如果您不关心kwargs，您可以：

def compose(*funcs):
    chain = lambda f, g: lambda *a: f(g(*a))
    return reduce(chain, funcs, lambda x: x)

例如：

>>> def compose(*funcs):
...     chain = lambda f, g: lambda *a: f(g(*a))
...     return reduce(chain, funcs, lambda x: x)
...
>>> remove_newlines = compose(lambda l: "".join(l), lambda s: s.split("\n"))
>>> remove_newlines("hello\n world")
'hello world'

注意：在python3中，reduce已从stdlib移到functools中，因此您需要从functools导入reduce执行
实现函数合成的常用方法如下：

def compose(*funcs):
    def _inner(x):
        functools.reduce(lambda acc, f: f(acc), funcs, x)
    return _inner

但是，为了修复代码，您可以执行以下操作：

def compose(*funcs):
    if not funcs:    # preferred to checking if len is 0
        return lambda x: x
    else:
        return lambda x: funcs[0](compose(*funcs[1:])(x))

实现功能组合的常用方法如下：

def compose(*funcs):
    def _inner(x):
        functools.reduce(lambda acc, f: f(acc), funcs, x)
    return _inner

但是，为了修复代码，您可以执行以下操作：

def compose(*funcs):
    if not funcs:    # preferred to checking if len is 0
        return lambda x: x
    else:
        return lambda x: funcs[0](compose(*funcs[1:])(x))

实现功能组合的常用方法如下：

def compose(*funcs):
    def _inner(x):
        functools.reduce(lambda acc, f: f(acc), funcs, x)
    return _inner

但是，为了修复代码，您可以执行以下操作：

def compose(*funcs):
    if not funcs:    # preferred to checking if len is 0
        return lambda x: x
    else:
        return lambda x: funcs[0](compose(*funcs[1:])(x))

实现功能组合的常用方法如下：

def compose(*funcs):
    def _inner(x):
        functools.reduce(lambda acc, f: f(acc), funcs, x)
    return _inner

但是，为了修复代码，您可以执行以下操作：

def compose(*funcs):
    if not funcs:    # preferred to checking if len is 0
        return lambda x: x
    else:
        return lambda x: funcs[0](compose(*funcs[1:])(x))

我是什么？一个数字还是一个函数？它是在所有函数上从头到尾运行的索引。因为我想做的是f1（f2（f3（……fn（x）））为什么你总是在第一次迭代后从for循环返回？而且
funcs[-1:0:-1]
写得更好
reversed（funcs[1:]）
imhow什么是i？一个数字还是一个函数？它是一个在所有函数上从头到尾运行的索引。因为我想做的是f1（f2（f3））（……fn（x）））为什么在第一次迭代后总是从for循环返回？而
funcs[-1:0:-1]
写得更好
reversed（funcs[1:]）
imhow什么是i？一个数字还是一个函数？它是一个从函数的末尾到开头都在所有函数上运行的索引。因为我想做的是f1（f2（f3（……fn（x）））为什么你总是在第一次迭代后从for循环返回？而
funcs[-1:0:-1]
写得更好
reversed（funcs[1:]）
imhow什么是i？一个数字还是一个函数？它是一个从结尾到开始在所有函数上运行的索引。因为我要做的是f1（f2（f3（……fn（x）））为什么您总是在第一次迭代后从for循环返回？而
funcs[-1:0:-1]
编写得更好
reversed（funcs[1:]）
i希望您确定不想将
反转
there@Eric修正了，我认为没有反转它就不能工作，但后来意识到它可以。你可以同样地编写它
lambda x:compose（*funcs[：-1]）（funcs[-1]（x））
非常确定您不希望
反转there@Eric修正了，我认为没有反转它就不能工作，但后来意识到它可以。你可以同样地编写它
lambda x:compose（*funcs[：-1]）（funcs[-1]（x））
非常确定您不希望
反转there@Eric修正了，我认为没有反转它就不能工作，但后来意识到它可以。你可以同样地编写它
lambda x:compose（*funcs[：-1]）（funcs[-1]（x））
非常确定您不希望
反转there@Eric修正了，我原以为没有反转就不行，但后来意识到它行了。你也可以写它