1

这是一个关于在字典理解内的列表理解上使用 set() 与字典理解和重复分配给新字典的性能的问题

所以我碰巧有一个数据集，它是一个列表列表，我需要获取一个唯一的元素列表，这些元素在大列表中的每个列表中索引为“0”，以便能够制作一个新字典从他们那里.. 像 dict.fromkeys() .. 在这里我需要提供唯一键列表..

我在用着

[1]{ x : [] for x in set([i[0] for i in data])}

并且还使用

[2]{ i[0] : [] for i in data}

此处供参考的样本数据可能如下： [[1,3,4], [3,5,2], [1,5,2]]

上面运行 [1] 和 [2] 的结果将是： { 1:[], 3: [] }

我在这两个语句上都尝试了 %timeit 并且都给出了几乎相同的结果，这使得很难确定哪个是最好的，性能方面，对于大列表

我如何在这里识别潜在的瓶颈？

编辑：

如果这有助于解释结果..

In [172]: data_new = data * 10000

In [173]: %timeit { i[0] : [] for i in data_new}
10 loops, best of 3: 160 ms per loop

In [174]: %timeit { x : [] for x in set([i[0] for i in data_new])}
10 loops, best of 3: 131 ms per loop

In [175]: data_new = data * 100000

In [176]: %timeit { x : [] for x in set([i[0] for i in data_new])}
1 loops, best of 3: 1.37 s per loop

In [177]: %timeit { i[0] : [] for i in data_new}
1 loops, best of 3: 1.58 s per loop

In [178]: data_new = data * 1000000

In [179]: %timeit { i[0] : [] for i in data_new}
1 loops, best of 3: 15.8 s per loop

In [180]: %timeit { x : [] for x in set([i[0] for i in data_new])}
1 loops, best of 3: 13.6 s per loop
4

2 回答 2

4

构建一个更大的数据集，然后 timeit：

代码：

import random
data = [ [random.randint(1, 9) for _ in range(3)] for _ in range(1000000)]

时间：

%timeit { x : [] for x in set([i[0] for i in data])}
# 10 loops, best of 3: 94.6 ms per loop
%timeit { i[0] : [] for i in data}
# 10 loops, best of 3: 106 ms per loop
%timeit { x: [] for x in set(i[0] for i in data)}
# 10 loops, best of 3: 114 ms per loop
%timeit { x: [] for x in {i[0] for i in data}}
# 10 loops, best of 3: 77.7 ms per loop

理由：

首先限制可用的键空间意味着字典只需分配（给定randint上述）9 个唯一键给 9 个新列表。使用 dict comp 时，字典必须重复创建并将其键的值重新分配给新创建的列表......不同之处在于释放丢弃的空列表（被垃圾收集）的开销和花费的时间创建一个新的空列表。

给定从 的均匀分布randint，那么对于 1,000,000 个元素的集合中的 9 个唯一值，有 111,111 次分配和取消分配空列表 - 这不仅仅是 9 个。

于 2015-01-28T13:56:11.690 回答
2

这取决于您期望的重复次数。在较短的代码中，为输入列表中的每个项目创建了一个空列表，这非常昂贵。使用静态值，越短越快。

在下面的，L = [[1,3,4], [3,5,2], [1,5,2]] * 100000

In [1]: %timeit { x : [] for x in {i[0] for i in L]}}
10 loops, best of 3: 58.9 ms per loop

In [2]: %timeit { i[0] : [] for i in L}
10 loops, best of 3: 68.1 ms per loop

现在在None这里用常数值进行测试：

In [3]: %timeit { x : None for x in set([i[0] for i in L])}
10 loops, best of 3: 59 ms per loop

In [4]: %timeit { i[0] : None for i in L}
10 loops, best of 3: 54.3 ms per loop

因此，不必要的列表创建使较短的列表执行缓慢，而使用恒定值绝对更快。

我没有适用于 Python 2 的 ipython 并且我有点懒惰，但你会想注意到 Python 2.7 支持set comprehensions，至少在 Python 3.4 上它比从列表创建集合要快得多：

In [7]: %timeit { x : [] for x in {i[0] for i in L}}
10 loops, best of 3: 48.9 ms per loop
于 2015-01-28T13:53:15.003 回答