如何将函数应用于python中列表的每个子列表？

Question

可以说我有一个这样的列表：

list_of_lists = [['how to apply'],['a function'],['to each list?']]

我有一个功能，让我们说我想要的应用F功能于各子列表F功能可以计算约两列出了一些成绩。 如何将此F函数应用于list_of_lists每个列表，并在新列表中返回每个分数，如下所示：

new_list = [score_1, score_2, score_3]

我尝试了以下map功能：

map(F, list_of_lists).append(new_list)

Answer 1

您可以使用内置map执行此操作。

因此，如果您要应用的函数是len ，您可以：

>>> list_of_lists = [['how to apply'],['a function'],['to each list?']]
>>> map(len, list_of_lists)
[1, 1, 1]

在Python3 ，上面返回一个map迭代器，因此你需要一个显式的list调用：

>>> map(len, list_of_lists)
<map object at 0x7f1faf5da208>
>>> list(map(len, list_of_lists))
[1, 1, 1]

---

如果您希望为此编写一些必须在Python2和Python3中兼容的代码，那么列表推导就是最佳选择。 就像是：

[apply_function(item) for item in list_of_lists]

将在Python 2和3中工作而不做任何更改。

但是，如果您的输入list_of_lists很大，那么在Python3中使用map会更有意义，因为迭代器会更快。

Answer 2

您可以使用列表推导，如下所示

[function_to_be_done(item) for item in list_of_lists]

例如，

>>> list_of_lists = [['how to apply'],['a function'],['to each list?']]
>>> [len(item) for item in list_of_lists]
[1, 1, 1]

注意：虽然列表推导看起来像是将函数应用于所有元素的方法，但其主要目的是构造一个新列表。 所以，如果你不想构造一个新的列表，那么只需用for循环迭代并调用该函数。

---

除此之外，您可以使用Python 2.7中的map函数将函数应用于所有元素并构造列表。 例如，

>>> list_of_lists = [['how to apply'],['a function'],['to each list?']]
>>> map(len, list_of_lists)
[1, 1, 1]

但是， map在Python 3.x中返回一个map迭代器对象。 因此，您需要将其显式转换为列表，如下所示

>>> list_of_lists = [['how to apply'],['a function'],['to each list?']]
>>> map(len, list_of_lists)
<map object at 0x7f94026afd30>
>>> list(map(len, list_of_lists))
[1, 1, 1]

---

你可能想要阅读一下Guido在这篇文章中对map看法。

基本上， map会更频繁地要求你创建一个新函数（大多数人创建一个lambda函数）。 但在许多情况下，列表理解避免了这种情况。

Answer 3

怎么样

[ F(x) for x in list_of_lists ]

将迭代list_of_lists，以每个子列表作为参数调用F，然后生成结果列表。

如果你想使用子列表作为F所有参数，你可以稍微不同地做

[ F(*x) for x in list_of_lists ]

Answer 4

可以在任意嵌套列表上运行的东西，例如[[1,2]，[[5]]，[7，[8，[9,11]]]]：

def apply_f(a,f):
 if isinstance(a,list):
     return map(lambda t:apply_f(t,f), a)
 else:
     return f(a)

这是运行这个的一个例子：

>>> ll=[[1,2],[[5]],[7,[8,[9,11]]]]
>>> apply_f(ll,lambda t:t**2)
[[1, 4], [[25]], [49, [64, [81, 121]]]]

---

以下是如何仅在选定的级别上执行相同的操作：

def apply_f(a,f,depth,levels):
    if isinstance(a,list):
        return map(lambda t:apply_f(t,f,depth+1,levels), a)
    else:
        if depth in levels:
            return f(a)
        else:
            return a

得到例如

>>> apply_f(ll,lambda t:t**2, 0, [2,4])
[[1, 4], [[5]], [49, [8, [81, 121]]]]

这里有一些优化，通过避免传递f和levels （使递归函数成为包装器中的内部函数，以便它可以使用外部作用域中的f和levels ），但这是次要的。 （请注意，这是Python 2，对于Python 3，您需要用其他东西替换map ）。

---

对于更通用的输入，以下方法可以解决这个问题：

def apply_f(a,f):
    try: 
       return(f(a))
    except:
       return map(lambda t:apply_f(t,f), a)

所以现在还有以下几种作品：

>> apply_f([(1,2),[[5]],[7,(8,[9,11])]],lambda t:t**2)
[[1, 4], [[25]], [49, [64, [81, 121]]]]

（稍微重写的东西，因为map()总是产生列表......）

Answer 5

地图是你的朋友！ map接受一个函数和一个iterable（例如list），并在列表的每个元素上应用该函数。

map(len, [['how to apply'],['a function'],['to each list?']]) 

产量

[1, 1, 1]

如果要对子列表的元素进行更精细的计算，可以嵌套映射：

map(lambda x: map(lambda y: y + 1, x), [[1], [1, 2], [1, 2, 3]])

产量

[[2], [2, 3], [2, 3, 4]]

另一种可能的方法（也来自函数式编程）是列表推导。 List comprehension是一种从Python中的iterable构造列表的方法。 语法是[element for element in iterable] 。 任何计算都可以在元素上完成，所以

[f(element) for element in iterable]

表示结果列表将是元素列表，其中每个元素是函数f的结果。 像map一样，list comprehension可以进一步嵌套，从而产生一个嵌套的元素函数应用程序。

[element + 1 for element in el] for el in [[1], [1, 2], [1, 2, 3]]]

产量

[[2], [2, 3], [2, 3, 4]]