Python: cómo agregar los contenidos de un iterable a un conjunto?

Question

¿Cuál es el "one [...] obvious way" para agregar todos los elementos de un iterable a uno existente set?

Answer 1

por el conjunto, ¿te refieres a 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

Me encanta esta manera:

set = [item for item in items] 

Answer 3

Uso lista por comprensión.

Un cortocircuito en la creación de una lista iterables usando por ejemplo :)

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

[Editar: se perdió la parte conjunto de pregunta]

Answer 4

for item in items: 
    extant_set.add(item) 

Para el registro, creo que la afirmación de que "No debe haber uno-- y preferiblemente sólo una manera --obvious para hacerlo." es falso Supone que muchas personas con mentalidad técnica creen que todos piensan igual. Lo que es obvio para una persona no es tan obvio para otra.

Yo diría que mi solución propuesta es claramente legible, y hace lo que pide. No creo que haya éxitos de rendimiento involucrados, aunque admito que me podría estar perdiendo algo. Pero a pesar de todo eso, puede que no sea obvio y preferible para otro desarrollador.

Answer 5

Los conjuntos tienen el método add también:

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

Usted puede utilizar la función set() para convertir un iterable en un conjunto, y luego usar el operador de actualización del conjunto estándar (| =) para agregar los valores únicos desde su nuevo conjunto al existente.

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

Answer 7

En beneficio de cualquier persona que pueda creer, p. que hacer aset.add() en un bucle tendría un rendimiento competitivo con hacer aset.update(), he aquí un ejemplo de cómo se puede poner a prueba sus creencias de forma rápida antes de hacerlo público:

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

Parece que el coste por artículo del enfoque de bucle es más de tres veces el del enfoque update.

El uso de |= set() cuesta alrededor de 1.5x que update hace la mitad de lo que agrega cada elemento individual en un ciclo.

Answer 8

Sólo una rápida actualización, los tiempos de uso de 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) 

resultados son los siguientes:

one_by_one 10.184448844986036 
cast_to_list_and_back 7.969255169969983 
update_set 2.212590195937082