Python 使用lambda映射与使用函数映射-如何将多个变量传递给函数？

我想学习在python中使用

map

，谷歌搜索给我带来了帮助

该页面上的一个代码使用for循环，并以一种有趣的方式将

map

放入for循环中，而

map

函数中使用的列表实际上包含两个函数的列表。代码如下：

def square(x): 
    return (x**2)

def cube(x):
    return (x**3)

funcs = [square, cube]

for r in range(5):
    value = map(lambda x: x(r), funcs)
    print value

输出：

[0, 0]
[1, 1]
[4, 8]
[9, 27]
[16, 64]

因此，在该教程的这一点上，我认为“如果您可以使用函数动态编写代码（lambda），那么可以使用标准函数使用

def

”编写代码。”。因此，我将代码更改为：

def square(x): 
    return (x**2)

def cube(x):
    return (x**3)

def test(x):
    return x(r)

funcs = [square, cube]

for r in range(5):
    value = map(test, funcs)
    print value

我得到了与第一段代码相同的输出，但是变量

r

取自全局名称空间，并且代码不是严格的函数式编程，这让我很烦恼。这就是我被绊倒的地方。这是我的密码：

def square(x): 
    return (x**2)

def cube(x):
    return (x**3)

def power(x):
    return x(r)

def main():
    funcs = [square, cube]
    for r in range(5):
        value = map(power, funcs)
        print value

if __name__ == "__main__":
    main()

我已经使用了这段代码，但问题是传递到函数

def power（x）

。我尝试了许多方法来传递到这个函数中，但是lambda能够自动为列表

funcs

的每次迭代分配

x

变量

---

有没有办法通过使用标准的

def

函数来实现这一点，或者这是不可能的，并且只能使用lambda？因为我正在学习python，这是我的第一门语言，所以我试图理解这里发生了什么。

您可以将

power（）

函数嵌套在

main（）

函数中：

def main():
    def power(x):
        return x(r)

    funcs = [square, cube]
    for r in range(5):
        value = map(power, funcs)
        print value

def power(r, x):
    return x(r)

def main():
    funcs = [square, cube]
    for r in range(5):
        value = map(lambda x: power(r, x), funcs)
        print value

因此，

r

现在再次从周围范围中获取，但不是全局范围。相反，它是一个闭包变量

但是，使用

lambda

只是从周围范围注入

r

并将其传递到

power（）函数的另一种方法：

def main():
    def power(x):
        return x(r)

    funcs = [square, cube]
    for r in range(5):
        value = map(power, funcs)
        print value

def power(r, x):
    return x(r)

def main():
    funcs = [square, cube]
    for r in range(5):
        value = map(lambda x: power(r, x), funcs)
        print value

这里
r
仍然是一个非本地的，取自父范围

您可以使用
r
作为第二个参数的默认值来创建lambda：

def power(r, x):
    return x(r)

def main():
    funcs = [square, cube]
    for r in range(5):
        value = map(lambda x, r=r: power(r, x), funcs)
        print value

现在，
r
作为默认值传入，因此它被视为本地值。但是，对于您的
map（）
，这实际上并没有什么区别。
为什么不将函数作为参数的一部分传递给
power（）
，并使用创建所需的
（value，func）
组合

from itertools import product

# ...

def power((value, func)):
    return func(value)

for r in range(5):
    values = map(power, product([r], funcs))
    print values

或者，如果您不希望/不要求按函数对结果进行分组，而是希望得到一个平面列表，您可以简单地执行以下操作：

values = map(power, product(range(5), funcs))
print values


注意：签名
power（（value，func））
定义了
power（）
以接受一个2元组参数，该参数自动解压为
value
和
func

相当于

def power(arg):
    value, func = arg

咖喱是另一种选择。由于两个参数的函数与一个参数的函数相同，该函数返回另一个函数，该函数接受其余参数，因此可以这样编写：

def square(x):
    return (x**2)

def cube(x):
    return (x**3)

def power(r):
    return lambda(x): x(r) # This is where we construct our curried function

def main():
    funcs = [square, cube]
    for y in range(5):
        value = map(power(y), funcs) # Here, we apply the first function
                                     # to get at the second function (which
                                     # was constructed with the lambda above).
        print value

if __name__ == "__main__":
    main()

为了使关系更明确一点，类型为
（a，b）->c
（一个接受类型为
a
的参数和类型为
b
的参数并返回类型为
c
的值的函数）等同于类型为
a->（b->c）
的函数

关于等价性的额外内容
如果你想更深入地了解这个等价关系背后的数学，你可以用一点代数来了解这个关系。将这些类型视为代数数据类型，我们可以将任何函数
a->b
转换为ba，将任何对
（a，b）
转换为a*b。由于这种连接，有时函数类型称为“指数”，对类型称为“乘积类型”。从这里我们可以看到

c（a*b）=（cb）a

所以,

(a, b) -> c  ~=  a -> (b -> c)