Cómo usar los conjuntos de Python (set)

Qué es un conjunto — sin duplicados, sin orden

Un conjunto (set) es, como list y tuple, un tipo para agrupar varios valores juntos. Pero tiene dos reglas que lo hacen muy diferente.

- Cada valor solo aparece una vez (los duplicados se eliminan automáticamente)

- El orden no se preserva (la posición no tiene significado)

Declara uno envolviendo los valores con { y }, separados por comas.

Para un conjunto vacío, usa set() en lugar de {}. Escribir {} te da un dict vacío.

# Los duplicados se eliminan automáticamente
set_a = {"a", "b", "c", "d", "a"}
print(set_a)         # {'a', 'b', 'c', 'd'} (el orden depende del entorno)
print(type(set_a))   # <class 'set'>
print(len(set_a))    # 4 (la 'a' duplicada se colapsa en una sola)

# Mezclar números y otros tipos está bien
mixed = {1, "apple", 3.14}

# Usa set() para un conjunto vacío
empty_set  = set()
empty_dict = {}        # esto se convierte en un "dict vacío"
print(type(empty_set))   # <class 'set'>
print(type(empty_dict))  # <class 'dict'>

# Usa in / not in para verificar la pertenencia
print("a" in set_a)       # True
print("z" not in set_a)   # True

Sin orden, por tanto sin acceso por índice

Como un conjunto no tiene orden, no puedes usar acceso por índice como set_a[0] (obtendrás un TypeError). Si necesitas el N-ésimo elemento, primero conviértelo a list o tuple y tómalo desde allí. Elige según el uso: list / tuple cuando el orden importe, set cuando no.

Vamos a confirmar cómo se comporta un conjunto.

① Crea tags = {"python", "web", "python", "ai", "web"}, luego print() el contenido y len(tags). Deberías ver los duplicados colapsar y el conteo bajar.

② print() tanto "python" in tags como "go" in tags para verificar la pertenencia con True / False.

(Si tu código se ejecuta correctamente, aparecerá la explicación.)

Añadir y eliminar elementos

Un conjunto es un tipo mutable, así que puedes añadir y eliminar elementos después de declararlo.

Los cinco métodos que usarás más son los siguientes.

fruits = {"apple", "banana", "lemon"}

# add
fruits.add("grape")
fruits.add("apple")     # ya está, ignorado
print(fruits)            # {'apple', 'banana', 'lemon', 'grape'}

# remove (error si no está)
fruits.remove("banana")
# fruits.remove("melon") # KeyError

# discard se mantiene callado aunque no esté
fruits.discard("melon")  # no pasa nada
print(fruits)            # {'apple', 'lemon', 'grape'}

# Elimina y devuelve un elemento arbitrario
picked = fruits.pop()
print(picked)            # algún elemento (varía en cada ejecución)

# Eliminar todo
fruits.clear()
print(fruits)            # set()

Gestionemos las etiquetas de interés de un usuario.

Se preparó interests = {"python", "web"}.

① Usa add para añadir "ai".

② Intenta add-ear el "python" ya existente otra vez, y confirma que el conjunto no cambia.

③ discard "go" (una etiqueta que no está) y confirma que no se lanza ningún error.

④ print() el interests final.

Operaciones de conjuntos — unión, intersección, diferencia, diferencia simétrica

La mayor característica de set son las operaciones de conjuntos. Puedes combinar dos conjuntos para sacar los elementos comunes, o los que aparecen en uno solo, en una sola línea. Podrías hacer lo mismo con un bucle for sobre listas, pero los conjuntos son mucho más rápidos.

• Unión — todos los elementos que aparecen en cualquiera de los conjuntos
• Intersección — solo los elementos que aparecen en ambos
• Diferencia — elementos en s pero no en t
• Diferencia simétrica — elementos que aparecen en exactamente uno de los dos

El diagrama de abajo muestra los resultados cuando s = {a, b, c, d} y t = {c, d, e, f}.

s = {"a", "b", "c", "d"}
t = {"c", "d", "e", "f"}

# Unión
print(s | t)                  # {'a', 'b', 'c', 'd', 'e', 'f'}
print(s.union(t))             # igual

# Intersección
print(s & t)                  # {'c', 'd'}
print(s.intersection(t))      # igual

# Diferencia (en s, no en t)
print(s - t)                  # {'a', 'b'}
print(s.difference(t))        # igual

# Diferencia simétrica (en exactamente uno)
print(s ^ t)                  # {'a', 'b', 'e', 'f'}
print(s.symmetric_difference(t))  # igual

Comprobaciones de subconjunto (nota al margen)

a <= b o a.issubset(b) te dice si todo elemento de a está en b, devolviendo True / False. La otra dirección es a >= b o a.issuperset(b).

Se usa para comprobaciones como «¿el conjunto de permisos del usuario contiene todos los permisos requeridos?». Al principio, concéntrate en las cuatro operaciones de conjuntos y recurre a estas cuando realmente las necesites.

A partir de las listas de inscripción de dos clases, encuentra los estudiantes inscritos en ambas y los inscritos en solo una.

Se preparó math = {"Ana", "Carlos", "Sofía", "Diego"} y english = {"Sofía", "Diego", "Laura", "Pablo"}.

① print() los estudiantes inscritos en ambas clases (intersección).

② print() los estudiantes inscritos en solo una clase (diferencia simétrica).

Patrones del mundo real — deduplicación y verificación rápida de pertenencia

Por último, aseguremos dos patrones infalibles que aparecen constantemente en el trabajo real.

# Patrón ①: deduplicación
numbers = [1, 2, 2, 2, 3, 4, 4, 5, 6, 6]
unique_numbers = list(set(numbers))
print(unique_numbers)   # [1, 2, 3, 4, 5, 6] (el orden puede variar)

# Patrón ②: verificación rápida de pertenencia
# x in set es mucho más rápido que x in list
allowed_users = {"alice", "bob", "carol"}
print("alice" in allowed_users)   # True
print("dan"   in allowed_users)   # False

Por qué in es rápido en un conjunto

Un conjunto está respaldado por una tabla hash. Busca los valores directamente por su hash, así que las búsquedas tardan un tiempo más o menos constante sin importar el tamaño.

in en una lista compara elementos uno por uno desde el principio, así que se vuelve más lento a medida que la lista crece. Si vas a comprobar la pertenencia muchas veces, convierte primero a conjunto y obtendrás una aceleración dramática.

Vamos a deduplicar entradas de log y verificar rápidamente si un usuario específico aparece.

Se preparó logins = ["alice", "bob", "alice", "carol", "bob", "alice"].

① Usa set para deduplicar en unique_logins (como lista) y luego print()-lo.

② Crea login_set convirtiendo unique_logins directamente a conjunto, y usa in para print() si "carol" y "dan" son miembros.

En este artículo has visto los rasgos de set (sin duplicados, sin orden), sus métodos de añadir/eliminar, las cuatro operaciones de conjuntos, y los dos patrones del mundo real — deduplicación y verificación rápida de pertenencia.

«No me importa el orden, solo quiero los únicos» / «Estoy comprobando la pertenencia una y otra vez» / «Necesito la intersección de dos conjuntos» — si te encaja alguno, es hora de recurrir a set.