Perché le tuple costruite da insiemi diversamente inizializzati sono uguali?

Question

mi aspettavo le seguenti due tuple

>>> x = tuple(set([1, "a", "b", "c", "z", "f"])) 
>>> y = tuple(set(["a", "b", "c", "z", "f", 1])) 

per confrontare diseguale, ma non lo fanno:

>>> x == y 
>>> True 

Perché?

Answer 1

A prima vista, sembra che x voglia sempre uguale y, perché due insiemi costruiti dagli stessi elementi sono sempre uguali:

>>> x = set([1, "a", "b", "c", "z", "f"]) 
>>> y = set(["a", "b", "c", "z", "f", 1]) 
>>> x 
{1, 'z', 'a', 'b', 'c', 'f'} 
>>> y 
{1, 'z', 'a', 'b', 'c', 'f'} 
>>> x == y 
True 

Tuttavia, è non sempre il caso che tuple (o altre raccolte ordinate) costruite da due serie uguali sono uguali.

In effetti, il risultato del confronto è talvolta True e talvolta False, almeno in Python> = 3.3. Testare il codice seguente:

# compare.py 
x = tuple(set([1, "a", "b", "c", "z", "f"])) 
y = tuple(set(["a", "b", "c", "z", "f", 1])) 
print(x == y) 

... mille volte:

$ for x in {1..1000} 
> do 
> python3.3 compare.py 
> done | sort | uniq -c 
147 False 
853 True 

Questo perché, dal momento che Python 3.3, i valori di hash di stringhe, byte e datetimes sono randomizzati a seguito di un security fix. A seconda di cosa sono gli hash, possono verificarsi "collisioni", il che significa che gli articoli dell'ordine sono memorizzati nell'array sottostante (e quindi l'ordine di iterazione) dipende dall'ordine di inserimento.

Ecco il bit rilevante dalla documentazione:

miglioramenti di sicurezza:

• Hash randomizzazione è attivata per impostazione predefinita.

- https://docs.python.org/3/whatsnew/3.3.html

EDIT: Dal momento che è menzionato nei commenti che il rapporto True/False sopra è superficialmente sorprendente ...

insiemi, come dizionari, vengono implementate come hash tabelle - quindi se c'è una collisione, l'ordine degli elementi nella tabella (e quindi l'ordine di iterazione) dipenderà sia dall'elemento che è stato aggiunto per primo (diverso in x e in t il suo caso) e il seme utilizzato per l'hashing (diverso per le invocazioni di Python dal 3.3). Dato che le collisioni sono rare per progettazione e gli esempi in questa domanda sono insiemi piccoli, il problema non si pone tutte le volte che si potrebbe supporre inizialmente.

Per una spiegazione completa dell'implementazione di Python di dizionari e insiemi, vedere The Mighty Dictionary.

Answer 2

I set non sono ordinati e sono definiti solo dalla loro appartenenza.

Ad esempio, set([1, 2]) == set([2, 1])

tuple sono uguali se i loro membri a ciascuna posizione sono uguali, ma poiché le collezioni tuple sono stati creati da iterate ugualmente (in ordine crescente), tuple finiscono per essere uguale pure.

Answer 3

quindi hai due elenchi, che hanno lo stesso contenuto ma in ordini diversi, li converti in set, che saranno uguali, poiché hanno lo stesso contenuto.

Quando convertite questi set in tuple, verranno convertiti nello stesso ordine, poiché sono lo stesso set, quindi le tuple saranno le stesse.

Questo è vero in Python2.7 - ma dal 3.3 in poi, quando gli hash sono randomizzati non sarà in grado di garantire questo - come le due serie, anche se uguali nei contenuti solito neccessarily iterare nello stesso ordine.

Answer 4

Ci sono due cose in gioco qui.

1. Gli insiemi non sono ordinati. set([1, "a", "b", "c", "z", "f"])) == set(["a", "b", "c", "z", "f", 1])

2. Quando si converte un set in una tupla tramite il costruttore tuple, itera essenzialmente sul set e aggiunge ogni elemento restituito dall'iterazione.

La sintassi costruttore di tuple è

tuple(iterable) -> tuple initialized from iterable's items 

Calling tuple(set([1, "a", "b", "c", "z", "f"])) è lo stesso di chiamare tuple([i for i in set([1, "a", "b", "c", "z", "f"])])

I valori per

[i for i in set([1, "a", "b", "c", "z", "f"])] 

e

[i for i in set(["a", "b", "c", "z", "f", 1])] 

sono gli stessi che itera sullo stesso set.

EDIT grazie a @ZeroPiraeus (controllare il suo answer). Questo non è garantito. Il valore dell'iterazione non sarà sempre lo stesso anche per lo stesso set.

Il costruttore di tuple non conosce l'ordine in cui è stato creato l'insieme.