¿Cómo agrego el contenido de un iterable a un conjunto?

Cuál es el “una […] manera obvia” para agregar todos los elementos de un iterable a uno existente set?

Puede agregar elementos de un list a un set como esto:

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

Para el beneficio de cualquiera que pudiera creer, por ejemplo, que hacer aset.add() en un bucle tendría un rendimiento competitivo con hacer aset.update()aquí hay un ejemplo de cómo puede probar sus creencias rápidamente 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 costo por elemento del enfoque de bucle es TRES veces mayor que el del update Acercarse.

Usando |= set() cuesta alrededor de 1.5x lo que update hace solo la mitad de lo que hace agregar cada elemento individual en un bucle.

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

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

Solo una actualización rápida, tiempos usando 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)

los resultados son:

one_by_one 10.184448844986036
cast_to_list_and_back 7.969255169969983
update_set 2.212590195937082

Usa la comprensión de listas.

Cortocircuitando la creación de iterable usando una lista, 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])
>>> 

[Edit: missed the set part of question]

for item in items:
   extant_set.add(item)

Para que conste, creo que la afirmación de que “debería haber una, y preferiblemente solo una, forma obvia de hacerlo”. es falso Hace una suposición que hacen muchas personas con mentalidad técnica, que todos piensan igual. Lo que es obvio para una persona no lo es tanto para otra.

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