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

Question

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

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

我想拉出一个,1和x并从中创建一个单独的列表.

我试过了:

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

Answer 1

使用列表理解:

>>> 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方式,转换数组:

%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 大约一μs,这仍然是10x的差异.

请注意,当我通过调用包围每个代码片段len以确保Generators运行到结束时,时间保持不变.