获得列表联合的最快方法-Python 有一个C++比较，从列表列表中获得列表的合并：

还有其他几个与python相关的问题，但没有一个建议使用最快的方法来统一列表：

从答案中，我发现至少有两种方法可以做到这一点：

>>> from itertools import chain
>>> x = [[1,2,3], [3,4,5], [1,7,8]]
>>> list(set().union(*x))
[1, 2, 3, 4, 5, 7, 8]
>>> list(set(chain(*x)))
[1, 2, 3, 4, 5, 7, 8]

请注意，我随后将集合强制转换为list，因为我需要确定列表的顺序以便进一步处理

经过一些比较，似乎

列表（set（chain（*x））

更稳定，花费的时间更少：

from itertools import chain
import time
import random

# Dry run.
x = [[random.choice(range(10000)) 
    for i in range(10)] for j in range(10)]
list(set().union(*x))
list(set(chain(*x)))

y_time = 0
z_time = 0

for _ in range(1000):
    x = [[random.choice(range(10000)) 
        for i in range(10)] for j in range(10)]
    start = time.time()
    y = list(set().union(*x))
    y_time += time.time() - start 
    #print 'list(set().union(*x)):\t', y_time
    start = time.time()
    z = list(set(chain(*x)))
    z_time += time.time() - start 
    #print 'list(set(chain(*x))):\t', z_time
    assert sorted(y) == sorted(z)
    #print 

print y_time / 1000.
print z_time / 1000. 

[out]：

1.39586925507e-05
1.09834671021e-05

1.22241973877e-05
1.02684497833e-05

取出要列出的铸造组变量：

y_time = 0
z_time = 0

for _ in range(1000):
    x = [[random.choice(range(10000)) 
        for i in range(10)] for j in range(10)]

    start = time.time()
    y = set().union(*x)
    y_time += time.time() - start 

    start = time.time()
    z = set(chain(*x))
    z_time += time.time() - start 

    assert sorted(y) == sorted(z)

print y_time / 1000.
print z_time / 1000. 

[out]：

1.39586925507e-05
1.09834671021e-05

1.22241973877e-05
1.02684497833e-05

以下是我尝试打印中间计时（无列表转换）时的完整输出：

为什么

list（set（chain（*x））

比

list（set（）.union（*x））

花费的时间更少？

---

是否有其他方法实现相同的列表合并？使用

numpy

或

pandas

或

sframe

或其他什么？是更快的选择吗？什么最快取决于

x

的性质——无论是长列表还是短列表，有许多子列表还是很少子列表，无论子列表是长还是短，重复的多还是少

以下是比较一些备选方案的timeit结果。有如此多的可能性，这绝不是一个完整的分析，但也许这将为您研究用例提供一个框架

func                 | x                    | time
unique_concatenate   | many_uniques         | 0.863
empty_set_union      | many_uniques         | 1.191
short_set_union_rest | many_uniques         | 1.192
long_set_union_rest  | many_uniques         | 1.194
set_chain            | many_uniques         | 1.224

func                 | x                    | time
long_set_union_rest  | many_duplicates      | 0.958
short_set_union_rest | many_duplicates      | 0.969
empty_set_union      | many_duplicates      | 0.971
set_chain            | many_duplicates      | 1.128
unique_concatenate   | many_duplicates      | 2.411

func                 | x                    | time
empty_set_union      | many_small_lists     | 1.023
long_set_union_rest  | many_small_lists     | 1.028
set_chain            | many_small_lists     | 1.032
short_set_union_rest | many_small_lists     | 1.036
unique_concatenate   | many_small_lists     | 1.351

func                 | x                    | time
long_set_union_rest  | few_large_lists      | 0.791
empty_set_union      | few_large_lists      | 0.813
unique_concatenate   | few_large_lists      | 0.814
set_chain            | few_large_lists      | 0.829
short_set_union_rest | few_large_lists      | 0.849

确保在您自己的机器上运行timeit基准测试，因为结果可能会有所不同

---

---

内部列表是否已排序？不，内部列表未显式排序。假定列表的输入列表的顺序未知。