La conversione di un elenco in un insieme modifica l'ordine degli elementi

Recentemente ho notato che quando si converte lista setnell'ordine degli elementi viene modificato e viene ordinato per carattere.

Considera questo esempio:

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

Le mie domande sono:

1. Perché sta succedendo?
2. Come posso eseguire operazioni di impostazione (in particolare Imposta differenza) senza perdere l'ordine iniziale?

1. A setè una struttura dati non ordinata, quindi non preserva l'ordine di inserzione.

2. Dipende dalle tue esigenze. Se si dispone di un elenco normale e si desidera rimuovere un insieme di elementi preservando l'ordine dell'elenco, è possibile farlo con una comprensione dell'elenco:

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

   Se hai bisogno di una struttura dati che supporti sia test rapidi di appartenenza che preservazione dell'ordine di inserzione , puoi utilizzare le chiavi di un dizionario Python, che a partire da Python 3.7 è garantito per preservare l'ordine di inserzione:

   >>> 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}

   bnon ha davvero bisogno di essere ordinato qui - potresti usare anche un file set. Tieni presente che a.keys() - b.keys()restituisce la differenza di set come a set, quindi non manterrà l'ordine di inserzione.

   Nelle versioni precedenti di Python, puoi usare collections.OrderedDictinvece:

   >>> 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)])

In Python 3.6, set()ora dovrebbe mantenere l'ordine, ma c'è un'altra soluzione per Python 2 e 3:

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

Rispondendo alla tua prima domanda, un set è una struttura dati ottimizzata per le operazioni di set. Come un insieme matematico, non impone né mantiene alcun ordine particolare degli elementi. Il concetto astratto di un insieme non impone l'ordine, quindi l'implementazione non è richiesta. Quando crei un set da un elenco, Python ha la libertà di modificare l'ordine degli elementi per le esigenze dell'implementazione interna che utilizza per un set, che è in grado di eseguire operazioni di set in modo efficiente.

rimuovere i duplicati e preservare l'ordine tramite la funzione sottostante

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

controlla questo link

In matematica, ci sono insiemi e insiemi ordinati (osets).

• set : un contenitore non ordinato di elementi unici (implementato)
• oset : un contenitore ordinato di elementi unici (NotImplemented)

In Python, solo i set vengono implementati direttamente. Possiamo emulare oset con i normali tasti dict ( 3.7+ ).

Dato

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

Codice

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

dimostrazione

I replicati vengono rimossi, l'ordine di inserzione viene mantenuto.

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

Operazioni di tipo set sui tasti Dict.

oset - b
# {1, 20, 210}

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

oset & b
# {2, 6}

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

Dettagli

Nota: una struttura non ordinata non preclude gli elementi ordinati. Piuttosto, l'ordine mantenuto non è garantito. Esempio:

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

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

Si può essere contenti di scoprire che una lista e un multiset (mset) sono due strutture di dati matematiche più affascinanti:

• list : un contenitore ordinato di elementi che consente repliche (implementato)
• mset : un contenitore non ordinato di elementi che consente repliche (NotImplemented) *

Sommario

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

^{* Un multiset può essere emulato indirettamente con collections.Counter(), una mappatura dict-like delle molteplicità (conteggi).}

Come indicato in altre risposte, gli insiemi sono strutture di dati (e concetti matematici) che non conservano l'ordine degli elementi -

Tuttavia, utilizzando una combinazione di set e dizionari, è possibile ottenere tutto ciò che desideri: prova a utilizzare questi frammenti:

# 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

Basandomi sulla risposta di Sven, ho scoperto che l'utilizzo di collections.OrderedDict in questo modo mi ha aiutato a realizzare ciò che desideri e mi ha permesso di aggiungere più elementi al dict:

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)])

Se vuoi aggiungere elementi ma trattalo comunque come un set puoi semplicemente fare:

z['nextitem']=None

E puoi eseguire un'operazione come z.keys () sul dict e ottenere il set:

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

Un'implementazione del concetto di punteggio più alto sopra che lo riporta a un elenco:

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

Testato (brevemente) su Python 3.6 e Python 2.7.

Nel caso in cui tu abbia un numero limitato di elementi nei tuoi due elenchi iniziali su cui desideri eseguire un'operazione di impostazione della differenza, invece di utilizzare il collections.OrderedDictche complica l'implementazione e lo rende meno leggibile, puoi utilizzare:

# 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]

La sua complessità temporale non è così buona, ma è chiara e facile da leggere.

È interessante che le persone usino sempre il "problema del mondo reale" per scherzare sulla definizione nella scienza teorica.

Se il set ha un ordine, devi prima capire i seguenti problemi. Se il tuo elenco contiene elementi duplicati, quale dovrebbe essere l'ordine quando lo trasformi in un set? Qual è l'ordine se uniamo due insiemi? Qual è l'ordine se intersechiamo due insiemi con ordine diverso sugli stessi elementi?

Inoltre, set è molto più veloce nella ricerca di una particolare chiave che è molto buona nel funzionamento dei set (ed è per questo che è necessario un set, ma non un elenco).

Se ti interessa davvero l'indice, tienilo come un elenco. Se si desidera comunque eseguire un'operazione di impostazione sugli elementi in molti elenchi, il modo più semplice è creare un dizionario per ogni elenco con le stesse chiavi nell'insieme insieme a un valore di elenco contenente tutto l'indice della chiave nell'elenco originale.

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}

Ecco un modo semplice per farlo:

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