42

如果我有序列序列（可能是元组列表），我可以使用 itertools.chain() 来展平它。但有时我觉得我宁愿把它写成一种理解。我只是不知道该怎么做。这是一个非常容易理解的案例：

假设我想交换序列中每一对的元素。我在这里使用字符串作为序列：

>>> from itertools import chain
>>> seq = '012345'
>>> swapped_pairs = zip(seq[1::2], seq[::2])
>>> swapped_pairs
[('1', '0'), ('3', '2'), ('5', '4')]
>>> "".join(chain(*swapped_pairs))
'103254'

我在序列的偶数和奇数切片上使用 zip 来交换对。但我最终得到了一个现在需要展平的元组列表。所以我使用链（）。有没有办法我可以用理解来表达它？

如果您想针对交换对的元素的基本问题发布您自己的解决方案，请继续，我会投票赞成任何教给我新知识的东西。但我只会将针对我的问题的答案标记为已接受，即使答案是“不，你不能。”。

4

4 回答 4

32

有领悟？好...

>>> seq = '012345'
>>> swapped_pairs = zip(seq[1::2], seq[::2])
>>> ''.join(item for pair in swapped_pairs for item in pair)
'103254'
于 2009-01-19T10:58:49.290 回答
16

我发现最快的是从一个空数组开始并扩展它：

In [1]: a = [['abc', 'def'], ['ghi'],['xzy']]

In [2]: result = []

In [3]: extend = result.extend

In [4]: for l in a:
   ...:     extend(l)
   ...: 

In [5]: result
Out[5]: ['abc', 'def', 'ghi', 'xzy']

这比 Alex Martelli 尝试中的示例快两倍多：Making a flat list out of lists in Python

$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99' '[item for sublist in l for item in sublist]'
10000 loops, best of 3: 86.3 usec per loop

$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]*99'  'b = []' 'extend = b.extend' 'for sub in l:' '    extend(sub)'
10000 loops, best of 3: 36.6 usec per loop

我想出这个是因为我有一种预感，在幕后，extend 会为列表分配适量的内存，并且可能使用一些低级代码来移动项目。我不知道这是否属实，但是谁在乎，它更快。

顺便说一句，这只是线性加速：

$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]'  'b = []' 'extend = b.extend' 'for sub in l:' '    extend(sub)'
1000000 loops, best of 3: 0.844 usec per loop

$ python -mtimeit -s'l=[[1,2,3],[4,5,6], [7], [8,9]]' '[item for sublist in l for item in sublist]'
1000000 loops, best of 3: 1.56 usec per loop

您也可以使用map(results.extend, a)，但这会比较慢，因为它正在构建自己的 None 列表。

它还为您提供了一些不使用函数式编程的好处。IE

  • 您可以扩展现有列表而不是创建一个空列表，
  • 你仍然可以一眼看懂代码，几分钟、几天甚至几个月后。

顺便说一句，最好避免列表推导。小的还不错，但一般来说，列表推导式实际上并不能为您节省很多打字时间，但通常更难理解，也很难更改或重构（见过三级列表推导式吗？）。谷歌编码指南建议不要使用它们，除非在简单的情况下。我的观点是它们只在“丢弃”代码中有用，即作者不关心可读性的代码，或者已知永远不需要将来维护的代码。

比较这两种写同一件事的方式：

result = [item for sublist in l for item in sublist]

有了这个：

result = []
for sublist in l:
    for item in sublist:
        result.append(item)

YMMV，但第一个让我停下了脚步，我不得不考虑一下。在第二个中，从缩进中可以明显看出嵌套。

于 2011-03-16T18:44:22.503 回答
3

您可以使用 reduce 来实现您的目标：

In [6]: import operator
In [7]: a = [(1, 2), (2,3), (4,5)]
In [8]: reduce(operator.add, a, ())
Out[8]: (1, 2, 2, 3, 4, 5)

这将返回一个元组而不是一个列表，因为原始列表中的元素是连接在一起的元组。但是您可以轻松地从中构建一个列表，并且 join 方法也接受元组。

顺便说一下，列表推导式不是正确的工具。基本上，列表推导通过描述该列表的元素应该是什么样子来构建一个新列表。您希望将元素列表减少到只有一个值。

于 2009-01-19T10:54:08.083 回答
1 
>>> a = [(1, 2), (3, 4), (5, 6)]
>>> reduce(tuple.__add__, a)
>>> (1, 2, 3, 4, 5, 6)

或者，不知道内部序列的类型（只要它们都相同）：

>>> reduce(a[0].__class__.__add__, a)
于 2009-01-19T14:34:44.487 回答