Métodos de conjuntos en Python – Referencia completa con ejemplos

Los conjuntos de Python son colecciones desordenadas de elementos únicos y hasheables. Dado que los conjuntos implementan el concepto matemático de conjunto, disponen de una amplia colección de métodos integrados para combinarlos, compararlos y modificarlos. Este capítulo cubre todos los métodos de conjunto integrados con ejemplos claros, la salida esperada y orientación sobre cuándo elegir un método frente a otro.

Si eres nuevo en los conjuntos, lee primero Python Sets para entender cómo se crean y en qué se diferencian de las listas y las tuplas.

Creación de conjuntos

Usa llaves {} o el constructor set() para crear un conjunto. El constructor también acepta cualquier iterable — una lista, tupla o string — y elimina duplicados automáticamente.

fruits = {'apple', 'banana', 'cherry'}
colors = set(['red', 'green', 'blue'])   # from a list
vowels = set('aeiou')                    # from a string → {'a', 'e', 'i', 'o', 'u'}

empty = set()   # NOT {} — that creates an empty dict

Los conjuntos son desordenados: el orden impreso de los elementos puede variar entre ejecuciones y versiones de Python.

Métodos de operaciones con conjuntos

Estos métodos combinan o comparan dos o más conjuntos sin modificar los originales.

union()

union(*others) devuelve un nuevo conjunto que contiene cada elemento que aparece en el conjunto actual o en cualquiera de los others.

El operador | es el equivalente abreviado para dos conjuntos: A | B.

Cuándo usarlo: para combinar varias colecciones eliminando duplicados en un solo paso.

intersection()

intersection(*others) devuelve un nuevo conjunto que contiene solo los elementos que aparecen en el conjunto actual y en cada uno de los others.

El operador & es la abreviatura para dos conjuntos: A & B.

Cuándo usarlo: para encontrar elementos comunes — por ejemplo, usuarios que hicieron clic tanto en el anuncio A como en el anuncio B.

difference()

difference(*others) devuelve un nuevo conjunto de elementos que están en el conjunto actual pero no en ninguno de los others.

El operador - es la abreviatura: A - B.

Cuándo usarlo: para filtrar un grupo de otro — por ejemplo, encontrar productos que están en stock pero que aún no han sido enviados.

symmetric_difference()

symmetric_difference(other) devuelve un nuevo conjunto de elementos que aparecen en exactamente uno de los dos conjuntos — los elementos que no son compartidos.

El operador ^ es la abreviatura: A ^ B.

Cuándo usarlo: para detectar qué cambió entre dos instantáneas — por ejemplo, archivos añadidos o eliminados entre dos listados de un directorio.

issubset()

issubset(other) devuelve True si cada elemento del conjunto actual también está en other.

El operador <= es equivalente; usa < para comprobar un subconjunto propio (A es más pequeño que B y está completamente contenido en él).

issuperset()

issuperset(other) devuelve True si el conjunto actual contiene cada elemento de other.

A = {1, 2, 3, 4, 5}
B = {2, 3}

print(A.issuperset(B))   # True
print(B.issuperset(A))   # False

El operador >= es equivalente; usa > para comprobar un superconjunto propio.

isdisjoint()

isdisjoint(other) devuelve True si los dos conjuntos no tienen ningún elemento en común — su intersección es vacía.

A = {1, 2, 3}
B = {4, 5, 6}
C = {3, 4, 5}

print(A.isdisjoint(B))   # True  — no overlap
print(A.isdisjoint(C))   # False — 3 is in both

Cuándo usarlo: para validar categorías no superpuestas, verificar que dos conjuntos de permisos son mutuamente excluyentes.

Métodos de actualización en el lugar

Estos métodos modifican el conjunto en el lugar y devuelven None — no crean un nuevo conjunto.

update()

update(*others) añade todos los elementos de uno o más iterables al conjunto actual, ignorando los duplicados.

update() acepta cualquier iterable, no solo otro conjunto — también funciona con una lista, tupla o string. El operador |= es la abreviatura para dos conjuntos.

intersection_update()

intersection_update(*others) conserva solo los elementos que también están en cada uno de los others, descartando todo lo demás.

A = {1, 2, 3, 4}
B = {2, 3, 4, 5}

A.intersection_update(B)
print(A)   # {2, 3, 4}

El operador &= es la abreviatura.

difference_update()

difference_update(*others) elimina del conjunto actual cada elemento que aparece en cualquiera de los others.

A = {1, 2, 3, 4}
B = {3, 4, 5}

A.difference_update(B)
print(A)   # {1, 2}

El operador -= es la abreviatura.

symmetric_difference_update()

symmetric_difference_update(other) conserva solo los elementos que aparecen en exactamente uno de los dos conjuntos, actualizando en el lugar.

A = {1, 2, 3}
B = {2, 3, 4}

A.symmetric_difference_update(B)
print(A)   # {1, 4}

El operador ^= es la abreviatura.

Métodos de manipulación de elementos

add()

add(elem) inserta elem en el conjunto. Si elem ya está presente, el conjunto no cambia.

Consulta Adding Set Items para ver más formas de poblar un conjunto.

remove()

remove(elem) elimina elem del conjunto. Lanza KeyError si elem no está presente.

Usa remove() cuando el elemento debe estar en el conjunto y su ausencia inesperada es un error de programación que vale la pena mostrar.

discard()

discard(elem) elimina elem del conjunto. No lanza un error si elem está ausente.

Usa discard() cuando el elemento puede o no estar en el conjunto y simplemente quieres eliminarlo.

pop()

pop() elimina y devuelve un elemento arbitrario. Como los conjuntos son desordenados, no puedes predecir qué elemento se elimina. Lanza KeyError si el conjunto está vacío.

Consulta Removing Set Items para una comparación de todos los enfoques de eliminación.

clear()

clear() elimina todos los elementos, dejando un conjunto vacío.

Ten en cuenta que print(set()) muestra set(), no {}, para distinguir un conjunto vacío de un diccionario vacío.

copy()

copy() devuelve una copia superficial del conjunto. Modificar la copia no afecta al original.

A = {1, 2, 3}
B = A.copy()

B.add(4)
print(A)   # {1, 2, 3}  — unchanged
print(B)   # {1, 2, 3, 4}

Esto es importante porque una asignación simple (B = A) crea una segunda referencia al mismo conjunto — los cambios en B también afectarían a A.

Método vs. operador: ¿cuál preferir?

La mayoría de las operaciones con conjuntos tienen tanto una forma de método como una forma de operador:

Diferencia clave: los métodos aceptan cualquier iterable como argumento, mientras que los operadores requieren que ambos lados sean conjuntos. Usa métodos cuando quieras operar directamente sobre una lista o tupla sin convertirla primero:

tags = {'python', 'web'}
new_tags = ['python', 'ml', 'data']

tags.update(new_tags)         # works — list is fine
# tags |= new_tags            # TypeError — operator needs a set
print(tags)   # {'python', 'web', 'ml', 'data'}

Referencia completa de métodos de conjuntos

Práctica