Conjuntos como colección sin duplicados: pertenencia y unicidad

Qué es un conjunto (set) y por qué se centra en la unicidad

Un conjunto es una colección de elementos donde no hay duplicados. Su idea principal no es “guardar en un orden”, sino responder bien a preguntas como: ¿este elemento ya está? y asegurar reglas como “solo uno por valor”. Por eso, cuando trabajas con conjuntos, el foco cambia de “recorrer para encontrar” a “comprobar pertenencia y mantener unicidad”.

Características clave:

• Unicidad: si intentas agregar un elemento que ya existe, el conjunto no cambia.
• Pertenencia: puedes comprobar si un elemento está o no está de forma directa.
• Sin depender del orden: no se usan posiciones (índices) para acceder a elementos.

Cuándo conviene usar conjuntos

1) Eliminar duplicados de una colección

Si recibes datos con repetidos (por ejemplo, etiquetas, correos, IDs), un conjunto te permite quedarte con valores únicos de manera natural.

tags = ["python", "datos", "python", "web", "datos"]  # lista con repetidos
unicos = set(tags)
# unicos contiene: {"python", "datos", "web"} (sin duplicados)

Observa que el resultado ya no está pensado para “mantener el orden original”, sino para representar “el conjunto de valores posibles”.

2) Controlar elementos ya vistos (evitar procesar dos veces)

En tareas de procesamiento (por ejemplo, leer registros, recorrer enlaces, manejar eventos), suele aparecer la necesidad de “no repetir trabajo”. Un conjunto es ideal para marcar lo ya visto.

Continúa en nuestra aplicación.

• Escuche el audio con la pantalla apagada.
• Obtenga un certificado al finalizar.
• ¡Más de 5000 cursos para que explores!

O continúa leyendo más abajo...

Descargar la aplicación

vistos = set()

for usuario_id in [10, 11, 10, 12, 11]:
    if usuario_id in vistos:
        continue  # ya lo procesé
    vistos.add(usuario_id)
    # procesar usuario_id una sola vez

3) Validar restricciones de unicidad

Casos típicos: usuarios únicos por email, nombres de usuario sin repetir, etiquetas únicas por artículo.

emails_registrados = {"a@correo.com", "b@correo.com"}

nuevo = "a@correo.com"
if nuevo in emails_registrados:
    # rechazar: ya existe
    pass
else:
    emails_registrados.add(nuevo)

Operaciones básicas: agregar, eliminar y comprobar existencia

Estas operaciones son el “día a día” de los conjuntos. El objetivo es pensar en términos de pertenencia y unicidad.

Comprobar existencia (pertenencia)

permitidos = {"admin", "editor", "lector"}
rol = "editor"

if rol in permitidos:
    # rol válido
    pass

Agregar elementos

Agregar no genera duplicados. Si el elemento ya estaba, el conjunto queda igual.

etiquetas = {"python", "backend"}
etiquetas.add("api")
etiquetas.add("python")  # no duplica

Eliminar elementos

Hay dos enfoques comunes: eliminar asumiendo que existe, o eliminar “si está” sin fallar.

activos = {101, 102, 103}

activos.remove(102)   # elimina 102 (si no existiera, sería un error)
activos.discard(999)  # no hace nada si 999 no existe

Comparación con el enfoque típico en listas (evitar búsquedas repetidas)

Cuando necesitas comprobar muchas veces si un elemento ya apareció, con listas suele implicar “buscar” repetidamente. Con conjuntos, el patrón mental es: “pregunto pertenencia y decido”.

# Evitar duplicados al construir una colección de IDs
ids_unicos = set()

for id_ in [5, 6, 5, 7, 6, 8]:
    if id_ not in ids_unicos:
        ids_unicos.add(id_)

Este patrón es especialmente útil cuando el flujo depende de “ya lo vi / no lo vi”.

Operaciones entre conjuntos aplicadas a problemas reales

Además de manejar elementos individuales, los conjuntos permiten combinar colecciones con operaciones muy expresivas.

Ejemplo 1: usuarios activos vs. registrados

Supón que tienes usuarios registrados y, por otro lado, usuarios que estuvieron activos hoy.

registrados = {"ana", "luis", "marta", "diego"}
activos_hoy = {"luis", "diego", "sofia"}

# Unión: todos los que aparecen en cualquiera de los dos grupos
cualquier_relacion = registrados | activos_hoy

# Intersección: activos que sí están registrados
activos_y_registrados = registrados & activos_hoy

# Diferencia: registrados que NO estuvieron activos hoy
inactivos_hoy = registrados - activos_hoy

# Diferencia inversa: activos que NO están registrados (posible anomalía)
activos_no_registrados = activos_hoy - registrados

Lectura práctica:

• registrados & activos_hoy te da el grupo “válido” de actividad.
• activos_hoy - registrados sirve para detectar eventos sospechosos o datos incompletos.

Ejemplo 2: etiquetas comunes entre artículos

Dos artículos tienen listas de etiquetas. Para comparar, conviene convertirlas a conjuntos y luego usar intersección.

tags_articulo_1 = set(["python", "datos", "etl", "api"])
tags_articulo_2 = set(["python", "web", "api", "seguridad"])

comunes = tags_articulo_1 & tags_articulo_2
solo_en_1 = tags_articulo_1 - tags_articulo_2
solo_en_2 = tags_articulo_2 - tags_articulo_1

todas = tags_articulo_1 | tags_articulo_2

Esto permite responder preguntas típicas:

• ¿Qué temas comparten? (comunes)
• ¿Qué temas son exclusivos de cada artículo? (solo_en_1, solo_en_2)
• ¿Qué catálogo total de temas aparece en ambos? (todas)

Guía práctica paso a paso: de una lista con repetidos a un conjunto y razonamiento del resultado

Objetivo: tomar una colección con duplicados, obtener valores únicos y usar pertenencia para validar reglas.

Paso 1: parte de una lista con repetidos

entradas = ["rojo", "azul", "rojo", "verde", "azul", "azul"]

Paso 2: conviértela en conjunto para quedarte con únicos

colores_unicos = set(entradas)

Razonamiento: el conjunto representa “los colores que aparecen al menos una vez”. La cantidad de elementos únicos se obtiene con:

cantidad = len(colores_unicos)

Paso 3: comprueba pertenencia para validar una restricción

Ejemplo: permitir solo colores de un catálogo.

catalogo = {"rojo", "azul", "verde", "negro"}

for c in colores_unicos:
    if c not in catalogo:
        # c es un valor no permitido
        pass

Paso 4: agrega y elimina para mantener el conjunto actualizado

colores_unicos.add("negro")
colores_unicos.discard("verde")

Razonamiento: aquí no estás “insertando en una posición”, sino actualizando el conjunto de valores válidos/observados.

Prácticas con datos pequeños

Práctica 1: deduplicar y contar

Dada la lista:

nombres = ["ana", "ana", "luis", "marta", "luis", "sofia"]

• Convierte a conjunto y obtén cuántos nombres únicos hay.
• Explica por qué el resultado ya no debe interpretarse como “en el mismo orden que llegó”.

Práctica 2: control de “ya visto”

Dada la secuencia:

eventos = ["login", "click", "login", "scroll", "click"]

• Usa un conjunto vistos para imprimir (o registrar) solo la primera vez que aparece cada evento.
• Describe qué cambia en tu lógica cuando decides “si está, no lo proceso”.

Práctica 3: operaciones entre conjuntos

Dados:

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

• Calcula a | b, a & b, a - b y b - a.
• Interpreta cada resultado como: “combinados”, “comunes”, “solo en a”, “solo en b”.