Python: come aggiungere il contenuto di un iterabile a un set?

Question

Che cos'è lo "one [...] obvious way" per aggiungere tutti gli elementi di un iterabile a uno esistente set?

Answer 1

dal set, vuoi dire set?

>>> foo = set(range(0, 4)) 
>>> foo 
set([0, 1, 2, 3]) 
>>> foo.update(range(2, 6)) 
>>> foo 
set([0, 1, 2, 3, 4, 5]) 

Answer 2

mi piace questo modo:

set = [item for item in items] 

Answer 3

Usa di lista.

corto circuito la creazione di iterabile usando una lista ad esempio :)

>>> x = [1, 2, 3, 4] 
>>> 
>>> k = x.__iter__() 
>>> k 
<listiterator object at 0x100517490> 
>>> l = [y for y in k] 
>>> l 
[1, 2, 3, 4] 
>>> 
>>> z = Set([1,2]) 
>>> z.update(l) 
>>> z 
set([1, 2, 3, 4]) 
>>> 

[Edit: mancava la parte insieme di domanda]

Answer 4

for item in items: 
    extant_set.add(item) 

Per la cronaca, credo che l'affermazione che "Ci dovrebbe essere tra-- e, preferibilmente, un solo modo --obvious per farlo." è fasullo. Presuppone che molte persone con idee tecniche creino, che tutti la pensano allo stesso modo. Ciò che è ovvio per una persona non è così ovvio per un altro.

Direi che la mia soluzione proposta è chiaramente leggibile e fa quello che chiedi. Non credo che ci siano dei successi nelle performance, anche se ammetto che potrei mancare qualcosa. Ma nonostante tutto, potrebbe non essere ovvio e preferibile a un altro sviluppatore.

Answer 5

Imposta hanno il metodo add troppo:

>>> s=set([1,2,3,4]) 
>>> for n in range(10): 
     s.add(n) 
>>> s 
set([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 

Answer 6

È possibile utilizzare la funzione set() per convertire un iterabile in un set, e quindi utilizzare operatore di aggiornamento insieme standard (| =) per aggiungere i valori univoci dal tuo nuovo set a quello esistente.

>>> a = { 1, 2, 3 } 
>>> b = (3, 4, 5) 
>>> a |= set(b) 
>>> a 
set([1, 2, 3, 4, 5]) 

Answer 7

Per il beneficio di chiunque possa credere ad es. che facendo aset.add() in un ciclo avrebbe prestazioni competitive con il fare aset.update(), ecco un esempio di come è possibile testare le vostre convinzioni in fretta prima di andare pubblico:

>\python27\python -mtimeit -s"it=xrange(10000);a=set(xrange(100))" "a.update(it)" 
1000 loops, best of 3: 294 usec per loop 

>\python27\python -mtimeit -s"it=xrange(10000);a=set(xrange(100))" "for i in it:a.add(i)" 
1000 loops, best of 3: 950 usec per loop 

>\python27\python -mtimeit -s"it=xrange(10000);a=set(xrange(100))" "a |= set(it)" 
1000 loops, best of 3: 458 usec per loop 

>\python27\python -mtimeit -s"it=xrange(20000);a=set(xrange(100))" "a.update(it)" 
1000 loops, best of 3: 598 usec per loop 

>\python27\python -mtimeit -s"it=xrange(20000);a=set(xrange(100))" "for i in it:a.add(i)" 
1000 loops, best of 3: 1.89 msec per loop 

>\python27\python -mtimeit -s"it=xrange(20000);a=set(xrange(100))" "a |= set(it)" 
1000 loops, best of 3: 891 usec per loop 

Sembra che il costo per punto di un approccio ciclo è più di tre volte quello dell'approccio update.

L'utilizzo di |= set() costa circa 1,5 volte il valore di update ma metà di ciò che aggiunge ogni singolo elemento in un ciclo.

Answer 8

Solo un rapido aggiornamento, timing utilizzando Python 3:

#!/usr/local/bin python3 
from timeit import Timer 

a = set(range(1, 100000)) 
b = list(range(50000, 150000)) 

def one_by_one(s, l): 
    for i in l: 
     s.add(i)  

def cast_to_list_and_back(s, l): 
    s = set(list(s) + l) 

def update_set(s,l): 
    s.update(l) 

risultati sono:

one_by_one 10.184448844986036 
cast_to_list_and_back 7.969255169969983 
update_set 2.212590195937082