Conjuntos en Python

Un conjunto (set) de Python es una colección desordenada de elementos únicos y hasheables. Dado que los conjuntos aplican la unicidad automáticamente y soportan pruebas de pertenencia rápidas, son ideales para la deduplicación, álgebra de conjuntos matemáticos y la verificación de solapamiento entre colecciones.

Este capítulo cubre:

• Cómo crear conjuntos (sintaxis literal y set())
• Agregar y eliminar elementos — y cuándo cada método lanza un error
• Las cuatro operaciones de conjuntos: unión, intersección, diferencia, diferencia simétrica
• Atajos de operadores (|, &, -, ^)
• Pruebas de subconjunto y superconjunto
• Comprensiones de conjuntos
• Conjuntos congelados (frozenset) para conjuntos inmutables y hasheables

Crear Conjuntos

Usando llaves

La forma más rápida de crear un conjunto no vacío es con un literal de llaves. Cada valor aparece solo una vez, independientemente de cuántas veces lo escribas.

Definir un conjunto en Python

Usando el constructor set()

Pasa cualquier iterable — una lista, tupla, string o range — a set() para construir un conjunto a partir de él. Los valores duplicados se eliminan silenciosamente.

Convertir una lista a un conjunto en Python

Importante: conjunto vacío

Para crear un conjunto vacío debes usar set(). Escribir {} crea un diccionario vacío, no un conjunto.

empty_set  = set()          # correct
empty_dict = {}             # this is a dict!

print(type(empty_set))   # <class 'set'>
print(type(empty_dict))  # <class 'dict'>

¿Qué puede contener un conjunto?

Un elemento de un conjunto debe ser hasheable — los tipos inmutables como int, float, str, bool y tuple funcionan bien. Las listas y otros conjuntos no pueden ser elementos porque son mutables y, por lo tanto, no son hasheables.

valid   = {1, "hello", (2, 3), True}  # OK
# invalid = {[1, 2]}                  # TypeError: unhashable type: 'list'
print(valid)

Acceder a los Elementos de un Conjunto

Los conjuntos son desordenados, por lo que los elementos no tienen índice y no puedes recuperar un elemento individual por posición. La forma estándar de recorrer todos los elementos es con un bucle for.

colors = {"red", "green", "blue"}
for color in colors:
    print(color)
# Output order may vary — sets are unordered

Para comprobar si existe un valor específico, usa el operador in:

colors = {"red", "green", "blue"}
print("red" in colors)    # True
print("yellow" in colors) # False

La comprobación de pertenencia en un conjunto es O(1) en promedio — mucho más rápida que buscar en una lista cuando las colecciones son grandes.

Para un capítulo dedicado, consulta Acceder a Elementos de un Conjunto.

Agregar Elementos

Usa add() para insertar un único elemento, o update() para agregar múltiples elementos desde cualquier iterable.

Agregar un elemento a un conjunto en Python

update() acepta cualquier iterable y agrega todos sus elementos:

my_set = {1, 2, 3}
my_set.update([4, 5], {6, 7})
print(my_set)   # {1, 2, 3, 4, 5, 6, 7}

Consulta Agregar Elementos a un Conjunto para más detalles.

Eliminar Elementos

Python ofrece varios métodos para eliminar elementos, cada uno con un comportamiento diferente cuando el elemento no existe.

Eliminar un elemento de un conjunto en Python

Cuándo elegir remove vs discard: usa remove() cuando el elemento debería estar presente y su ausencia indica un error. Usa discard() cuando el elemento pueda o no estar y simplemente quieras que desaparezca.

Consulta Eliminar Elementos de un Conjunto para todos los métodos de eliminación.

Operaciones de Conjuntos

Los conjuntos de Python implementan las cuatro operaciones clásicas de álgebra de conjuntos. Cada operación está disponible tanto como método como operador — elige el que sea más claro en cada contexto.

Operaciones de conjuntos en Python

set1 = {1, 2, 3}
set2 = {2, 3, 4}

# Union — all elements from both sets
print(set1.union(set2))              # {1, 2, 3, 4}
print(set1 | set2)                   # {1, 2, 3, 4}

# Intersection — only elements present in both
print(set1.intersection(set2))       # {2, 3}
print(set1 & set2)                   # {2, 3}

# Difference — elements in set1 but not set2
print(set1.difference(set2))         # {1}
print(set1 - set2)                   # {1}

# Symmetric difference — elements in either set, but not both
print(set1.symmetric_difference(set2))  # {1, 4}
print(set1 ^ set2)                      # {1, 4}

Comprobaciones de subconjunto y superconjunto

Usa issubset(), issuperset(), o los operadores de comparación <= / >= para probar relaciones de contención.

a = {1, 2}
b = {1, 2, 3, 4}

print(a.issubset(b))    # True  — every element of a is in b
print(a <= b)           # True

print(b.issuperset(a))  # True  — b contains all elements of a
print(b >= a)           # True

print(a < b)            # True  — proper subset (a != b)
print(a == b)           # False

isdisjoint() retorna True cuando dos conjuntos no comparten ningún elemento:

x = {1, 2, 3}
y = {4, 5, 6}
print(x.isdisjoint(y))  # True

Consulta Unir Conjuntos para variantes de actualización en el lugar como |=, &=, -= y ^=.

Comprensiones de Conjuntos

Al igual que las comprensiones de listas, puedes construir un conjunto con una expresión compacta usando llaves y una cláusula for.

squares = {x ** 2 for x in range(1, 6)}
print(squares)  # {1, 4, 9, 16, 25}

# With a filter condition
even_squares = {x ** 2 for x in range(1, 11) if x % 2 == 0}
print(even_squares)  # {4, 16, 36, 64, 100}

Dado que el resultado es un conjunto, los valores duplicados se colapsan automáticamente:

words = ["apple", "banana", "avocado", "blueberry"]
first_letters = {w[0] for w in words}
print(first_letters)  # {'a', 'b'}

Conjuntos Congelados

Un frozenset es una versión inmutable de un conjunto. Una vez creado, no se pueden agregar ni eliminar elementos. Los conjuntos congelados son hasheables, lo que significa que pueden usarse como claves de diccionario o como elementos de otro conjunto.

fs = frozenset([1, 2, 3])
print(fs)               # frozenset({1, 2, 3})

# All read-only operations work
print(2 in fs)          # True
print(fs | {4, 5})      # frozenset({1, 2, 3, 4, 5})

# fs.add(4)             # AttributeError — frozenset has no add()

# Use as a dictionary key
permissions = {
    frozenset(["read", "write"]): "editor",
    frozenset(["read"]):          "viewer",
}
user_perms = frozenset(["read", "write"])
print(permissions[user_perms])  # editor

Cuándo usar frozenset: siempre que necesites un objeto similar a un conjunto que no deba cambiar — como configuración constante, una clave de diccionario segura, o al compartir un conjunto entre hilos sin bloqueo.

Ejemplos Prácticos

Eliminar duplicados de una lista

Convertir a un conjunto y volver es la forma más sencilla de deduplicar una lista. Ten en cuenta que el orden original no se preserva; si el orden importa, usa dict.fromkeys() en su lugar.

Eliminar duplicados de una lista usando un conjunto en Python

Verificar si dos listas comparten algún elemento

Verificar si dos listas tienen elementos en común en Python usando conjuntos

isdisjoint() es una alternativa más directa para esta comprobación:

list1 = [1, 2, 3]
list2 = [4, 5, 6]
print(not set(list1).isdisjoint(set(list2)))  # False — no common elements

Encontrar etiquetas únicas entre artículos

article_a_tags = {"python", "tutorial", "beginner"}
article_b_tags = {"python", "advanced", "data-science"}

all_tags    = article_a_tags | article_b_tags
shared_tags = article_a_tags & article_b_tags
only_in_a   = article_a_tags - article_b_tags

print("All tags:    ", all_tags)
print("Shared tags: ", shared_tags)
print("Only in A:   ", only_in_a)

Resumen

Capítulos relacionados: Agregar Elementos a un Conjunto · Eliminar Elementos de un Conjunto · Acceder a Elementos de un Conjunto · Recorrer Conjuntos · Unir Conjuntos · Métodos de Conjuntos

Práctica