Konwersja listy na zbiór zmienia kolejność elementów

Ostatnio zauważyłem, że kiedy jestem konwertowania listdo setrzędu elementów ulega zmianie i jest klasyfikowane według charakteru.

Rozważmy ten przykład:

x=[1,2,20,6,210]
print x 
# [1, 2, 20, 6, 210] # the order is same as initial order

set(x)
# set([1, 2, 20, 210, 6]) # in the set(x) output order is sorted

Moje pytania to -

1. Dlaczego to się dzieje?
2. Jak mogę wykonać operacje na zestawach (zwłaszcza na ustawieniach różnicy) bez utraty pierwotnego zamówienia?

1. A setto nieuporządkowana struktura danych, więc nie zachowuje kolejności reklamowej.

2. To zależy od twoich wymagań. Jeśli masz normalną listę i chcesz usunąć jakiś zestaw elementów, zachowując kolejność na liście, możesz to zrobić za pomocą zrozumienia listy:

   >>> a = [1, 2, 20, 6, 210]
   >>> b = set([6, 20, 1])
   >>> [x for x in a if x not in b]
   [2, 210]

   Jeśli potrzebujesz struktury danych, która obsługuje zarówno szybkie testy członkostwa, jak i zachowanie kolejności wstawiania , możesz użyć kluczy ze słownika Pythona, który począwszy od Pythona 3.7 gwarantuje zachowanie kolejności wstawiania:

   >>> a = dict.fromkeys([1, 2, 20, 6, 210])
   >>> b = dict.fromkeys([6, 20, 1])
   >>> dict.fromkeys(x for x in a if x not in b)
   {2: None, 210: None}

   btak naprawdę nie trzeba tutaj zamawiać - możesz też użyć set. Pamiętaj, że a.keys() - b.keys()zwraca różnicę zestawu jako a set, więc nie zachowa zamówienia reklamowego.

   W starszych wersjach Pythona możesz collections.OrderedDictzamiast tego użyć :

   >>> a = collections.OrderedDict.fromkeys([1, 2, 20, 6, 210])
   >>> b = collections.OrderedDict.fromkeys([6, 20, 1])
   >>> collections.OrderedDict.fromkeys(x for x in a if x not in b)
   OrderedDict([(2, None), (210, None)])

W Pythonie 3.6 set()teraz powinno zachować kolejność, ale jest inne rozwiązanie dla Pythona 2 i 3:

>>> x = [1, 2, 20, 6, 210]
>>> sorted(set(x), key=x.index)
[1, 2, 20, 6, 210]

Odpowiadając na pierwsze pytanie, zbiór to struktura danych zoptymalizowana pod kątem operacji na zbiorach. Podobnie jak zbiór matematyczny, nie wymusza ani nie utrzymuje określonej kolejności elementów. Abstrakcyjna koncepcja zestawu nie wymusza porządku, więc nie jest wymagana realizacja. Kiedy tworzysz zestaw z listy, Python ma swobodę zmiany kolejności elementów na potrzeby wewnętrznej implementacji, której używa dla zbioru, który jest w stanie efektywnie wykonywać operacje na zbiorach.

usuń duplikaty i zachowaj kolejność za pomocą poniższej funkcji

def unique(sequence):
    seen = set()
    return [x for x in sequence if not (x in seen or seen.add(x))]

sprawdź ten link

W matematyce istnieją zbiory i zbiory uporządkowane (osety).

• zestaw : nieuporządkowany pojemnik z unikalnymi elementami (zaimplementowany)
• oset : uporządkowany kontener unikalnych elementów (NotImplemented)

W Pythonie tylko zestawy są implementowane bezpośrednio. Możemy emulować osety zwykłymi klawiszami dyktowania ( 3.7+ ).

Dany

a = [1, 2, 20, 6, 210, 2, 1]
b = {2, 6}

Kod

oset = dict.fromkeys(a).keys()
# dict_keys([1, 2, 20, 6, 210])

Próbny

Repliki są usuwane, kolejność wstawiania zostaje zachowana.

list(oset)
# [1, 2, 20, 6, 210]

Operacje podobne do zestawów na klawiszach dyktowania.

oset - b
# {1, 20, 210}

oset | b
# {1, 2, 5, 6, 20, 210}

oset & b
# {2, 6}

oset ^ b
# {1, 5, 20, 210}

Detale

Uwaga: nieuporządkowana konstrukcja nie wyklucza zamówionych elementów. Raczej nie gwarantuje się zachowania porządku. Przykład:

assert {1, 2, 3} == {2, 3, 1}                    # sets (order is ignored)

assert [1, 2, 3] != [2, 3, 1]                    # lists (order is guaranteed)

Z przyjemnością odkryjesz, że lista i zestaw wielozbiorowy (mset) to dwie bardziej fascynujące, matematyczne struktury danych:

• lista : uporządkowany kontener elementów, który umożliwia replikacje (wdrożony)
• mset : nieuporządkowany kontener elementów, który pozwala na replikacje (NotImplemented) *

Podsumowanie

Container | Ordered | Unique | Implemented
----------|---------|--------|------------
set       |    n    |    y   |     y
oset      |    y    |    y   |     n
list      |    y    |    n   |     y
mset      |    n    |    n   |     n*  

^{* Multiset może być pośrednio emulowany za collections.Counter()pomocą dyktowanego odwzorowania wielokrotności (zliczeń).}

Jak wskazano w innych odpowiedziach, zbiory są strukturami danych (i pojęciami matematycznymi), które nie zachowują kolejności elementów -

Jednak korzystając z kombinacji zestawów i słowników, możliwe jest, że możesz osiągnąć to, co chcesz - spróbuj użyć tych fragmentów:

# save the element order in a dict:
x_dict = dict(x,y for y, x in enumerate(my_list) )
x_set = set(my_list)
#perform desired set operations
...
#retrieve ordered list from the set:
new_list = [None] * len(new_set)
for element in new_set:
   new_list[x_dict[element]] = element

Opierając się na odpowiedzi Svena, odkryłem, że używam kolekcji.OrderedDict pomogło mi osiągnąć to, co chcesz, a także pozwoliło mi dodać więcej elementów do dyktu:

import collections

x=[1,2,20,6,210]
z=collections.OrderedDict.fromkeys(x)
z
OrderedDict([(1, None), (2, None), (20, None), (6, None), (210, None)])

Jeśli chcesz dodać przedmioty, ale nadal traktować to jak zestaw, możesz po prostu zrobić:

z['nextitem']=None

I możesz wykonać operację taką jak z.keys () na dyktacie i pobrać zestaw:

z.keys()
[1, 2, 20, 6, 210]

Implementacja powyższej koncepcji najwyższego wyniku, która sprowadza ją z powrotem do listy:

def SetOfListInOrder(incominglist):
    from collections import OrderedDict
    outtemp = OrderedDict()
    for item in incominglist:
        outtemp[item] = None
    return(list(outtemp))

Przetestowano (krótko) na Pythonie 3.6 i Pythonie 2.7.

Jeśli masz niewielką liczbę elementów na dwóch początkowych listach, na których chcesz wykonać operację ustawiania różnicy, zamiast używać, collections.OrderedDictktóra komplikuje implementację i czyni ją mniej czytelną, możesz użyć:

# initial lists on which you want to do set difference
>>> nums = [1,2,2,3,3,4,4,5]
>>> evens = [2,4,4,6]
>>> evens_set = set(evens)
>>> result = []
>>> for n in nums:
...   if not n in evens_set and not n in result:
...     result.append(n)
... 
>>> result
[1, 3, 5]

Jego złożoność czasowa nie jest zbyt dobra, ale jest schludna i łatwa do odczytania.

Ciekawe, że ludzie zawsze używają „problemu ze świata rzeczywistego”, aby żartować z definicji w naukach teoretycznych.

Jeśli zestaw ma porządek, najpierw musisz rozwiązać następujące problemy. Jeśli Twoja lista zawiera zduplikowane elementy, jaka powinna być kolejność, gdy zamienisz ją w zestaw? Jaka jest kolejność, jeśli połączymy dwa zestawy? Jaka jest kolejność, jeśli przecinamy dwa zbiory o różnej kolejności na tych samych elementach?

Dodatkowo set znacznie szybciej wyszukuje określony klucz, co jest bardzo dobre w działaniu na zestawach (dlatego potrzebny jest zestaw, ale nie lista).

Jeśli naprawdę zależy Ci na indeksie, zachowaj go jako listę. Jeśli nadal chcesz wykonywać operacje na elementach na wielu listach, najprostszym sposobem jest utworzenie słownika dla każdej listy z tymi samymi kluczami w zestawie wraz z wartością listy zawierającą cały indeks klucza z oryginalnej listy.

def indx_dic(l):
    dic = {}
    for i in range(len(l)):
        if l[i] in dic:
            dic.get(l[i]).append(i)
        else:
            dic[l[i]] = [i]
    return(dic)

a = [1,2,3,4,5,1,3,2]
set_a  = set(a)
dic_a = indx_dic(a)

print(dic_a)
# {1: [0, 5], 2: [1, 7], 3: [2, 6], 4: [3], 5: [4]}
print(set_a)
# {1, 2, 3, 4, 5}

Oto prosty sposób na zrobienie tego:

x=[1,2,20,6,210]
print sorted(set(x))