Python: jak dodać zawartość pliku iteracyjnego do zestawu?

Question

Co to jest "one [...] obvious way", aby dodać wszystkie elementy wersji do istniejącego set?

Answer 1

przez zestaw, masz na myśli 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

Kocham ten sposób:

set = [item for item in items] 

Answer 3

Zastosowanie lista zrozumieniem.

Krótkie spięcie tworzenie iterable używając listę na przykład :)

>>> 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: brakowało nastawioną część Pytanie]

Answer 4

for item in items: 
    extant_set.add(item) 

Dla przypomnienia, myślę, że twierdzenie, że „nie powinno być jedno- i korzystnie tylko jeden --obvious sposób to zrobić.” jest fałszywe. Przyjmuje założenie, że wielu myślących technicznie ludzi sprawia, że ​​wszyscy myślą tak samo. To, co dla jednej osoby jest oczywiste, nie jest tak oczywiste dla drugiego.

Chciałbym argumentować, że proponowane przeze mnie rozwiązanie jest czytelne i spełnia to, o co prosisz. Nie wierzę, że są w to zaangażowane jakieś hity wydajności - choć przyznaję, że czegoś mi brakowało. Ale mimo wszystko, może nie być oczywiste i lepsze od innego programisty.

Answer 5

Zestawy posiadają metodę dodawać zbyt:

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

można użyć funkcji set() do konwersji iterable w zestawie, a następnie użyć standardowego operatora zestaw aktualizacji (| =), aby dodać unikatowe wartości od nowego zestawu do istniejącego.

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

Answer 7

Dla korzyści każdego, kto może wierzyć np. że robi aset.add() w pętli miałby wydajność konkurencyjnej robi aset.update(), oto przykład jak można przetestować swoje przekonania szybko przed upublicznieniem:

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

Wygląda kosztów za przesyłkę podejścia pętli jest ponad trzykrotnie z podejścia update.

Używanie |= set() kosztuje około 1,5x to, co robi update, ale połowę tego, co dodaje każdy pojedynczy element w pętli.

Answer 8

Tylko szybka zmiana, czasy przy użyciu Pythona 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) 

Wyniki są następujące:

one_by_one 10.184448844986036 
cast_to_list_and_back 7.969255169969983 
update_set 2.212590195937082