Uzyskaj listę unikalnych wielu zestawów

Question

Jak mogę uniquify następującą listę w Pythonie:

all_the_ways = [(5,), (2, 2, 1), (2, 1, 2), (2, 1, 1, 1), (1, 2, 2),\ 
       (1, 2, 1, 1), (1, 1, 2, 1), (1, 1, 1, 2), (1, 1, 1, 1, 1)] 

Pożądany wyjścia:

[(5,), (2, 2, 1), (2, 1, 1, 1), (1, 1, 1, 1, 1)] 

czyli muszę pozbyć krotek, które mają takie same zestaw liczb, ale w innej kolejności.

Próbowałem

set(all_the_ways) 

ale tylko transpozycja elementów.

I kiedy zrobić

list(map(set, all_the_ways)) 

rzeczy tylko coraz gorzej:

[{5}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1, 2}, {1}] 

Innymi słowy muszę konwertować wewnętrzną krotki do kolekcji, która pozwala kilku równych elementów (set nie jest odpowiedni) i dla których permutacje elementów nie zmieniają samej kolekcji (trochę jak C++ 's multiset)

Answer 1

Jak o tym:

list(set(tuple(sorted(s)) for s in all_the_ways)) 

wyjściowa:

[(1, 2, 2), (5,), (1, 1, 1, 1, 1), (1, 1, 1, 2)] 

Będzie magiel kolejność każdej krotki chociaż. Zakładam, że to nie ma znaczenia, ponieważ krotki zawierające ten sam zestaw liczb są uważane za takie same dla twojego przypadku. Co oznacza to, że w końcu, lista wyjściowa może zawierać krotki, które nie należą do pierwotnego wejścia, na przykład (kredyt do @thefourtheye):

all_the_ways = [(2, 1, 2), (2, 2, 1)] 
# Output: [(1, 2, 2)] 

To może lub nie może być problemem, a jeśli można użyć bardziej niezawodnych rozwiązań, o których już wspominano w innych znakomitych odpowiedziach.

Answer 2

Uważam, że dwa elementy są "równe", jeśli zawierają te same wartości, niezależnie od kolejności.

Więc może „canonicalize” każda krotka sortując ją przekształcić z powrotem do krotek (a więc są hashable) i usunąć duplikaty używając set ponownie:

set(tuple(sorted(tup)) for tup in all_the_ways) 

Można również zachować oryginalne „zewnętrzny” zamówienie, używając OrderedSet zamiast set.

Answer 3

Zastosowanie collections.Counter() zidentyfikować unikalne multisets:

>>> from collections import Counter 

>>> all_the_ways = [(5,), (2, 2, 1), (2, 1, 2), (2, 1, 1, 1), (1, 2, 2),\ 
       (1, 2, 1, 1), (1, 1, 2, 1), (1, 1, 1, 2), (1, 1, 1, 1, 1)] 
>>> result = [] 
>>> seen = set() 
>>> for tup in all_the_ways: 
     key = tuple(sorted(Counter(tup).items())) # unique signature 
     if key not in seen: 
      result.append(tup) 
     seen.add(key) 

>>> result 
[(5,), (2, 2, 1), (2, 1, 1, 1), (1, 1, 1, 1, 1)] 

Answer 4

może być to?:

result = {tuple(sorted(x)) for x in all_the_ways} 

Answer 5

Jeśli zamówienie nie ma znaczenia, można użyć tej

from collections import Counter 
>>> {frozenset(Counter(tup).items()):tup for tup in data}.values() 
# [(1, 2, 2), (1, 1, 1, 2), (1, 1, 1, 1, 1), (5,)] 

Jeśli chcesz zachować porządek,

from collections import Counter, OrderedDict 
OrderedDict([frozenset(Counter(tup).items()),tup] for tup in data).values() 
# [(5,), (1, 2, 2), (1, 1, 1, 2), (1, 1, 1, 1, 1)] 

W obu rozwiązaniach możemy liczyć na frozenset, ponieważ obiekty set nie są nieaktualne, ponieważ można je zmieniać. W pierwszym przypadku konstruujemy słownik z częstotliwością liczb (określaną jako Counter) jako kluczem i bieżącą krotką jako wartością odpowiadającą temu. Po zakończeniu budowy słownika, przyjmujemy wszystkie wartości, które odpowiadają krotkom.

W drugim przypadku po prostu używamy OrderedDict, aby utrzymać zamówienie.

Answer 6

Spróbuj

from collections import OrderedDict 
print OrderedDict.fromkeys(map(lambda x: tuple(sorted(x)), all_the_ways)).keys() 

lub

print set(map(lambda x: tuple(sorted(x)), all_the_ways))