Объединение нескольких наборов в python

Модуль itertools быстро справляется с работой этой проблемы:

>>> from itertools import chain
>>> list(set(chain.from_iterable(d)))
[1, '41', '42', '43', '40', '34', '30', '44']

Другой способ сделать это — распаковать список в отдельные аргументы для union():

>>> list(set().union(*d))
[1, '41', '42', '43', '40', '34', '30', '44']

Последний способ устраняет все дубликаты и не требует, чтобы входные данные сначала преобразовывались в наборы. Кроме того, он не требует импорта.

Используя оператор распаковки *:

>> list(set().union(*a))
[1, '44', '30', '42', '43', '40', '41', '34']

(Спасибо Raymond Hettinger и ShadowRanger за комментарии!)

(Обратите внимание, что

set.union(*tup)

распаковать в

set.union(tup[0], tup[1], ... tup[n - 1])

)

Вы можете использовать itertools для выполнения этого действия. Предположим, что в вашем списке есть имя переменной A

import itertools

single_list_with_all_values = list(itertools.chain(*A))
single_list_with_all_values.sort()

print set(single_list_with_all_values)

In [20]: s
Out[20]: 
[[1, '34', '44'],
 [1, '40', '30', '41'],
 [1, '41', '40', '42'],
 [1, '42', '41', '43'],
 [1, '43', '42', '44'],
 [1, '44', '34', '43']]
In [31]: list({x for _list in s for x in _list})
Out[31]: [1, '44', '30', '42', '43', '40', '41', '34']

Обновлять:

Спасибо за комментарии

>>> big = [[1, '34', '44'], [1, '40', '30', '41'], [1, '41', '40', '42'], [1, '42', '41', '43'], [1, '43', '42', '44'], [1, '44', '34', '43']]
>>> set(reduce ( lambda l,a : l + a, big))
set([1, '44', '30', '42', '43', '40', '41', '34'])

И если вам действительно нужен список списка в качестве конечного результата

>>>>[list(set(reduce ( lambda l,a : l + a, big)))]
[[1, '44', '30', '42', '43', '40', '41', '34']]

И если вам не нравится перекодировать лямбда-функцию для добавления в список:

>>>>[list(set(reduce ( list.__add__, big)))]
[[1, '44', '30', '42', '43', '40', '41', '34']]

EDIT: после вашей рекомендации использовать itertools.chain вместо list.__add__ я запустил timeit для обоих с исходной переменной, используемой исходным плакатом.

Кажется, что timeit list.__add__ около 2,8 с, а itertools.chain около 3,5 секунды.

Я проверил на этой странице, и да, вы были правы с тем, что itertools.chain содержит метод from_iterable, который дает огромный прирост производительности. см. ниже список.__add__, itertools.chain и itertools.chain.from_iterable.

>>> timeit.timeit("[list(set(reduce ( list.__add__, big)))]", setup="big = [ [10,20,30,40] for ele in range(10000)]", number=30)
16.051744650801993
>>> timeit.timeit("[list(set(reduce ( itertools.chain, big)))]", setup="big = [ [10,20,30,40] for ele in range(10000)]", number=30)
54.721315866467194
>>> timeit.timeit("list(set(itertools.chain.from_iterable(big)))", setup="big = [ [10,20,30,40] for ele in range(10000)]", number=30)
0.040056066849501804

Большое спасибо за ваши советы :)

from functools import reduce

out = list(reduce(set.union, iterable))

пока хотя бы первый элемент iterable является набором. Иначе,

out = list(reduce(set.union, iterable[1:], set(iterable[0])))

Протестировано только с python 2: мне лично нравится читабельность reduce в сочетании с простой условной функцией, что-то вроде

# PYTHON 2 ONLY!
somelists = [[1, '41', '40', '42'], [1, '42', '41', '43'], [1, '43', '42', '44'], [1, '44', '34', '43']] # your original lists
somesets = map(set,somelists) #your lists as sets

def condition(s1,s2): # condition to apply recursively to the sets
    if s1.intersection(s2):
        return s1.union(s2)
reduce( condition,somesets)
#{1, '30', '34', '40', '41', '42', '43', '44'}

Конечно, вы можете привести этот результат к 2d-списку, если хотите list([reduce(...

Отмечу, что это примерно в 3 раза медленнее, чем ответ chain.fromiterable.