Question

我想知道在列表列表中提取每个子列表的第一项的最佳方法是什么，并将其附加到新列表中。如果我有：

lst = [[a,b,c], [1,2,3], [x,y,z]]

我想提取a，1和x，并从中创建单独的列表。

我试过了：

lst2.append(x[0] for x in lst)

Answer 1

使用list comprehension：

>>> lst = [['a','b','c'], [1,2,3], ['x','y','z']]
>>> lst2 = [item[0] for item in lst]
>>> lst2
['a', 1, 'x']

Answer 2

您可以使用zip：

>>> lst=[[1,2,3],[11,12,13],[21,22,23]]
>>> zip(*lst)[0]
(1, 11, 21)

或者，Python {3} zip不生成列表：

>>> list(zip(*lst))[0]
(1, 11, 21)

或者，

>>> next(zip(*lst))
(1, 11, 21)

或者，（我最喜欢的）使用numpy：

>>> import numpy as np
>>> a=np.array([[1,2,3],[11,12,13],[21,22,23]])
>>> a
array([[ 1,  2,  3],
       [11, 12, 13],
       [21, 22, 23]])
>>> a[:,0]
array([ 1, 11, 21])

Answer 3

Python包含一个名为itemgetter的函数，用于返回列表中特定索引处的项目：

from operator import itemgetter

将itemgetter（）函数传递给要检索的项目的索引。要检索第一个项目，您将使用itemgetter（0）。要理解的重要一点是itemgetter（0）本身返回一个函数。如果将列表传递给该函数，则会得到特定项：

itemgetter(0)([10, 20, 30]) # Returns 10

当你将它与map（）结合使用时会很有用，map（）将函数作为第一个参数，将列表（或任何其他可迭代的）作为第二个参数。它返回在iterable中对每个对象调用函数的结果：

my_list = [['a', 'b', 'c'], [1, 2, 3], ['x', 'y', 'z']]
list(map(itemgetter(0), my_list)) # Returns ['a', 1, 'x']

请注意，map（）返回一个生成器，因此将结果传递给list（）以获取实际列表。总之，您的任务可以这样完成：

lst2.append(list(map(itemgetter(0), lst)))

这是使用列表推导的另一种方法，选择哪种方法高度依赖于上下文，可读性和首选项。

更多信息： https://docs.python.org/3/library/operator.html#operator.itemgetter

Answer 4

有同样的问题，并对每个解决方案的性能感到好奇。

这是%timeit：

import numpy as np
lst = [['a','b','c'], [1,2,3], ['x','y','z']]

第一个numpy-way，转换数组：

%timeit list(np.array(lst).T[0])
4.9 µs ± 163 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

完全原生使用列表理解（由@alecxe解释）：

%timeit [item[0] for item in lst]
379 ns ± 23.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

使用zip的另一种原生方式（由@dawg解释）：

%timeit list(zip(*lst))[0]
585 ns ± 7.26 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

第二个numpy-way。同样由@dawg解释：

%timeit list(np.array(lst)[:,0])
4.95 µs ± 179 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

令人惊讶的是（好吧，至少对我而言）使用列表理解的本地方式是最快的，比numpy方式快10倍。在没有最终list的情况下运行两个numpy-way会节省大约1μs，这仍然是10倍差异。

请注意，当我通过调用len包围每个代码段时，为了确保Generators运行到最后，时间保持不变。

Answer 5

您的代码几乎是正确的。唯一的问题是使用列表理解。

如果使用like：（x [1]为x中的x），则返回生成器对象。如果你使用：[x [0] for x in lst]，它会返回一个列表。

当您将列表推导输出附加到列表时，列表推导的输出是列表的单个元素。

lst = [["a","b","c"], [1,2,3], ["x","y","z"]]
lst2 = []
lst2.append([x[0] for x in lst])
print lst2[0]

lst2 = [[＆＃39; a＆＃39;，1，＆＃39; x＆＃39;]]

lst2 [0] = [＆＃39; a＆＃39;，1，＆＃39; x＆＃39;]

如果我不对，请告诉我。

Answer 6

lst = [['a','b','c'], [1,2,3], ['x','y','z']]
outputlist = []
for values in lst:
    outputlist.append(values[0])

print(outputlist)

输出：['a', 1, 'x']

Answer 7

你说你有一个现有的清单。所以我会那样做。

>>> lst1 = [['a','b','c'], [1,2,3], ['x','y','z']]
>>> lst2 = [1, 2, 3]

现在您将生成器对象附加到第二个列表。

>>> lst2.append(item[0] for item in lst)
>>> lst2
[1, 2, 3, <generator object <genexpr> at 0xb74b3554>]

但你可能希望它成为第一项的列表

>>> lst2.append([item[0] for item in lst])
>>> lst2
[1, 2, 3, ['a', 1, 'x']]

现在我们将第一项列表添加到现有列表中。如果您想将项目自身添加到现有项目中，而不是将它们列入现有项目，则可以使用list.extend。在这种情况下，我们不必担心添加生成器，因为extend将使用该生成器添加从中获取的每个项目，以扩展当前列表。

>>> lst2.extend(item[0] for item in lst)
>>> lst2
[1, 2, 3, 'a', 1, 'x']

或

>>> lst2 + [x[0] for x in lst]
[1, 2, 3, 'a', 1, 'x']
>>> lst2
[1, 2, 3]

https://docs.python.org/3.4/tutorial/datastructures.html#more-on-lists https://docs.python.org/3.4/tutorial/datastructures.html#list-comprehensions

提取每个子列表的第一项

7 个答案: