使用python map和其他功能工具

这相当不错，但是我正在尝试学习/理解python中的函数式编程。如下代码：

foos = [1.0,2.0,3.0,4.0,5.0]
bars = [1,2,3]

def maptest(foo, bar):
    print foo, bar

map(maptest, foos, bars)

产生：

1.0 1
2.0 2
3.0 3
4.0 None
5.0 None

问：有没有一种方法可以使用map或python中的任何其他功能工具来产生以下内容而没有循环等。

1.0 [1,2,3]
2.0 [1,2,3]
3.0 [1,2,3]
4.0 [1,2,3]
5.0 [1,2,3]

顺便提一下，如果foo和bar之间存在依赖关系，则实现将如何更改。例如

foos = [1.0,2.0,3.0,4.0,5.0]
bars = [1,2,3,4,5]

并打印：

1.0 [2,3,4,5]
2.0 [1,3,4,5]
3.0 [1,2,4,5]
...

PS：我知道如何使用if，循环和/或生成器天真地做到这一点，但是我想学习如何使用功能性工具来实现这一点。是否只是在maptest中添加if语句或在maptest内部将其他过滤器映射应用于bar的情况？

最简单的方法是不bars通过不同的功能，而直接从maptest以下位置访问它：

foos = [1.0,2.0,3.0,4.0,5.0]
bars = [1,2,3]

def maptest(foo):
    print foo, bars

map(maptest, foos)

使用原始maptest函数，您还可以在map以下代码中使用lambda函数：

map((lambda foo: maptest(foo, bars)), foos)

您是否熟悉其他功能语言？即，您是要学习python如何进行函数编程，还是要学习有关函数编程并使用python作为工具？

另外，您了解列表理解吗？

map(f, sequence)

与（*）直接等效：

[f(x) for x in sequence]

实际上，我认为map()曾经打算从python 3.0中删除它是多余的（那没有发生）。

map(f, sequence1, sequence2)

大致等于：

[f(x1, x2) for x1, x2 in zip(sequence1, sequence2)]

（在处理序列长度不同的情况时，它的处理方式有所不同。如您所见，map()当其中一个序列用完时，填入None，而zip()当最短序列停止时，则填满）

因此，为了解决您的特定问题，您尝试产生结果：

foos[0], bars
foos[1], bars
foos[2], bars
# etc.

您可以通过编写一个带有单个参数并打印它的函数，然后加上杠来做到这一点：

def maptest(x):
     print x, bars
map(maptest, foos)

或者，您可以创建一个如下所示的列表：

[bars, bars, bars, ] # etc.

并使用原始的maptest：

def maptest(x, y):
    print x, y

一种方法是事先显式构建列表：

barses = [bars] * len(foos)
map(maptest, foos, barses)

或者，您可以拉入itertools模块。 itertools包含许多巧妙的功能，可帮助您在python中进行功能风格的延迟评估编程。在这种情况下，我们需要itertools.repeat，当您对其进行迭代时，它将无限期地输出其参数。最后一个事实意味着，如果您这样做：

map(maptest, foos, itertools.repeat(bars))

map()只要参数之一仍在产生输出，您就会得到无穷的输出，因为它一直持续下去。但是，itertools.imap就像map()，但最短的可迭代停止就停止。

itertools.imap(maptest, foos, itertools.repeat(bars))

希望这可以帮助 ：-）

（*）在python 3.0中有些不同。在那里，map（）本质上返回一个生成器表达式。

这是您要寻找的解决方案：

>>> foos = [1.0, 2.0, 3.0, 4.0, 5.0]
>>> bars = [1, 2, 3]
>>> [(x, bars) for x in foos]
[(1.0, [1, 2, 3]), (2.0, [1, 2, 3]), (3.0, [1, 2, 3]), (4.0, [1, 2, 3]), (5.0, [
1, 2, 3])]

我建议使用列表理解（[(x, bars) for x in foos]部分）而不是使用地图，因为它避免了每次迭代时函数调用的开销（这可能非常重要）。如果只打算在for循环中使用它，则可以通过使用生成器理解来获得更好的速度：

>>> y = ((x, bars) for x in foos)
>>> for z in y:
...     print z
...
(1.0, [1, 2, 3])
(2.0, [1, 2, 3])
(3.0, [1, 2, 3])
(4.0, [1, 2, 3])
(5.0, [1, 2, 3])

区别在于生成器理解迟缓地加载。

更新 针对此评论：

当然，您知道您不复制栏，所有条目都是相同的栏列表。因此，如果您修改其中的任何一个（包括原始条），那么您将修改所有的它们。

我想这是一个正确的观点。我可以想到两种解决方案。最有效的可能是这样的：

tbars = tuple(bars)
[(x, tbars) for x in foos]

由于元组是不可变的，因此这将防止通过此列表理解的结果（或通过该路线生成器理解）的结果来修改钢筋。如果确实需要修改每个结果，则可以执行以下操作：

from copy import copy
[(x, copy(bars)) for x in foos]

但是，这在内存使用和速度方面都可能会有些昂贵，因此我建议您不要这样做，除非您确实需要添加每个内存。

函数式编程是关于创建无副作用的代码。

map是功能列表转换的抽象。您可以使用它来获取一系列序列并将其转换为其他序列。

您正在尝试将其用作迭代器。不要那样做 :)

这是一个示例，说明如何使用地图构建所需的列表。有较短的解决方案（我只是使用理解力），但这将帮助您了解哪种地图效果更好：

def my_transform_function(input):
    return [input, [1, 2, 3]]

new_list = map(my_transform, input_list)

请注意，此时您仅完成了数据操作。现在您可以打印它：

for n,l in new_list:
    print n, ll

-我不确定“没有循环”是什么意思。fp并不是要避免循环（您无法访问列表中的每个项目都无法对其进行检查）。这是关于避免副作用，从而减少错误。

>>> from itertools import repeat
>>> for foo, bars in zip(foos, repeat(bars)):
...     print foo, bars
... 
1.0 [1, 2, 3]
2.0 [1, 2, 3]
3.0 [1, 2, 3]
4.0 [1, 2, 3]
5.0 [1, 2, 3]

import itertools

foos=[1.0, 2.0, 3.0, 4.0, 5.0]
bars=[1, 2, 3]

print zip(foos, itertools.cycle([bars]))

以下是该map(function, *sequences)函数的参数概述：

• function 是函数的名称。
• sequences是任意数量的序列，通常是列表或元组。 map将同时迭代它们，并将当前值提供给function。这就是为什么序列数应等于函数的参数数的原因。

听起来您正在尝试迭代某些function参数，但保持其他参数不变，但是不幸的map是不支持该参数。我发现了一个向Python添加此类功能的旧建议，但是map构造是如此干净且完善，以至于我怀疑这样的东西是否会实现。

像其他人建议的那样，使用诸如全局变量或列表理解之类的解决方法。

这样可以吗？

foos = [1.0,2.0,3.0,4.0,5.0]
bars = [1,2,3]

def maptest2(bar):
  print bar

def maptest(foo):
  print foo
  map(maptest2, bars)

map(maptest, foos)

这个怎么样：

foos = [1.0,2.0,3.0,4.0,5.0]
bars = [1,2,3]

def maptest(foo, bar):
    print foo, bar

map(maptest, foos, [bars]*len(foos))