在 Python 中提取每个子列表的第一项

使用列表推导式：

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

您的代码几乎是正确的。唯一的问题是列表推导式的使用。

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

将列表推导式输出追加到列表时，列表推导式导出的输出是列表的单个元素。

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

lst2 = [['a'， 1， 'x']]

lst2[0] = ['a'， 1， 'x']

如果我不正确，请告诉我。

你说你有一个现有的列表。所以我会这样做。

>>> 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

您可以使用 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])

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

from operator import itemgetter

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

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

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

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

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

print(outputlist) 

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

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

这是：%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)

另一种原生使用方式（如@dawg所述）：zip

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

第二种麻木方式。@dawg也解释了：

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

令人惊讶的是（好吧，至少对我来说）使用列表推导的原生方式是最快的，比 numpy-way 快约 10 倍。在没有 final 的情况下运行两种 numpy-ways 可以节省大约 1 μs，这仍然在 10 倍的差异中。list

请注意，当我用 的调用包围每个代码片段以确保生成器运行到最后时，时间保持不变。len

我可以建议的另一个答案是

lst = [['a','b','c'], [1,2,3], ['x','y','z']]
new_lst=[lst[0][0],lst[1][0],lst[2][0]]
print(new_lst)

输出如下

['a'， 1， 'x']

希望这会有所帮助！谢谢！

您可以将列表列表中的第一个值提取到新列表中，如下所示：

list_of_lists = [
    ['John', 'Anna'], [36, 24], ['Male', 'Female']
] 
           
new_list = [list[0] for list in list_of_lists] # Here

print(new_list) # ['John', 36, 'Male']

或：

list_of_lists = [
    ['John', 'Anna'], [36, 24], ['Male', 'Female']
] 
           
new_list = [first for [first, second] in list_of_lists] # Here

print(new_list) # ['John', 36, 'Male']