如何从元组列表中提取第 n 个元素

问题描述：

我正在尝试从元组列表中获取第 n 个元素。

我有类似的东西：

elements = [(1,1,1),(2,3,7),(3,5,10)]

我希望仅将每个元组的第二个元素提取到列表中：

seconds = [1, 3, 5]

我知道这可以通过for循环来完成，但我想知道是否还有其他方法，因为我有数千个元组。

解决方案 1：

n = 1 # N. . .
[x[n] for x in elements]

解决方案 2：

这也有效：

zip(*elements)[1]

（我发布这个主要是为了向自己证明我已经理解了zip......）

观看实际操作：

>>> help(zip)

有关模块builtin中内置函数zip的帮助：

拉链（...）

zip(序列1 [, 序列2 [...]]) -> [(序列1[0], 序列2[0] ...), (...)]

返回一个元组列表，其中每个元组包含每个参数序列中的第 i 个元素。返回的列表的长度被截断为最短参数序列的长度。

>>> elements = [(1,1,1),(2,3,7),(3,5,10)]
>>> zip(*elements)
[(1, 2, 3), (1, 3, 5), (1, 7, 10)]
>>> zip(*elements)[1]
(1, 3, 5)
>>>

我今天学到了一件很有趣的事情：*list在参数中使用来为函数创建参数列表......

注意：在 Python3 中，zip返回一个迭代器，所以改为使用list(zip(*elements))返回元组列表。

解决方案 3：

我知道可以用 FOR 来完成，但我想知道是否还有其他方法

还有另一种方法。你也可以使用map和itemgetter来实现：

>>> from operator import itemgetter
>>> map(itemgetter(1), elements)

但这仍然在内部执行循环，并且比列表理解稍慢：

setup = 'elements = [(1,1,1) for _ in range(100000)];from operator import itemgetter'
method1 = '[x[1] for x in elements]'
method2 = 'map(itemgetter(1), elements)'

import timeit
t = timeit.Timer(method1, setup)
print('Method 1: ' + str(t.timeit(100)))
t = timeit.Timer(method2, setup)
print('Method 2: ' + str(t.timeit(100)))

结果：

方法 1：1.25699996948
方法 2：1.46600008011

如果您需要遍历列表，那么使用for就可以了。

解决方案 4：

我在搜索哪种方法最快提取二元组列表的第二个元素时发现了这一点。这不是我想要的，但使用第三种方法运行了相同的测试，并测试了 zip 方法

setup = 'elements = [(1,1) for _ in range(100000)];from operator import itemgetter'
method1 = '[x[1] for x in elements]'
method2 = 'map(itemgetter(1), elements)'
method3 = 'dict(elements).values()'
method4 = 'zip(*elements)[1]'

import timeit
t = timeit.Timer(method1, setup)
print('Method 1: ' + str(t.timeit(100)))
t = timeit.Timer(method2, setup)
print('Method 2: ' + str(t.timeit(100)))
t = timeit.Timer(method3, setup)
print('Method 3: ' + str(t.timeit(100)))
t = timeit.Timer(method4, setup)
print('Method 4: ' + str(t.timeit(100)))

Method 1: 0.618785858154
Method 2: 0.711684942245
Method 3: 0.298138141632
Method 4: 1.32586884499

因此，如果您有一对二元组，只需将其转换为字典并获取值，速度就会提高一倍以上。

解决方案 5：

Python 3.6从二元组列表中提取第二个元素的时间。

此外，还添加了numpy数组方法，它更容易阅读（但可以说比列表理解更简单）。

from operator import itemgetter
elements = [(1,1) for _ in range(100000)]

%timeit second = [x[1] for x in elements]
%timeit second = list(map(itemgetter(1), elements))
%timeit second = dict(elements).values()
%timeit second = list(zip(*elements))[1]
%timeit second = np.array(elements)[:,1]

以及时间安排：

list comprehension:  4.73 ms ± 206 µs per loop
list(map):           5.3 ms ± 167 µs per loop
dict:                2.25 ms ± 103 µs per loop
list(zip)            5.2 ms ± 252 µs per loop
numpy array:        28.7 ms ± 1.88 ms per loop

请注意map()，zip()不再返回列表，因此需要显式转换。

解决方案 6：

map (lambda x:(x[1]),elements)

解决方案 7：

使用islice和chain.from_iterable：

>>> from itertools import chain, islice
>>> elements = [(1,1,1),(2,3,7),(3,5,10)]
>>> list(chain.from_iterable(islice(item, 1, 2) for item in elements))
[1, 3, 5]

当你需要多个元素时这会很有用：

>>> elements = [(0, 1, 2, 3, 4, 5), 
                (10, 11, 12, 13, 14, 15), 
                (20, 21, 22, 23, 24, 25)]
>>> list(chain.from_iterable(islice(tuple_, 2, 5) for tuple_ in elements))
[2, 3, 4, 12, 13, 14, 22, 23, 24]

解决方案 8：

我喜欢@daren 的回答，但它给出了一个错误，即zip无法订阅，因为您无法对zip迭代器进行切片。相反，您需要将添加zip到 a 中list，以根据索引提取所需的元素。

elements = [(1,1,1),(2,3,7),(3,5,10)]
slices = list(zip(*elements))[1]

输出：

(1, 3, 5)