Python · Lección 11 de 27

Sets (conjuntos)

Los sets son colecciones sin duplicados y sin orden. Son la herramienta ideal para deduplicar datos, verificar pertenencia instantáneamente y hacer operaciones matemáticas de conjuntos (unión, intersección, diferencia).

60–80 min Prerrequisitos: 08 Listas, 10 Diccionarios

Concepto teórico

¿Qué es un set?

Un set (conjunto) es una colección desordenada de elementos únicos. Cuando agregás un elemento que ya existe, el set simplemente lo ignora. Se crean con llaves {} o con la función set().

colores = {"rojo", "azul", "verde", "rojo", "azul"}
print(colores)  # {"rojo", "azul", "verde"} — sin duplicados

# ¡CUIDADO! {} crea un dict vacío, NO un set
vacio_dict = {}      # esto es un diccionario vacío
vacio_set = set()    # esto es un set vacío

Las 3 propiedades clave de los sets: (1) Sin duplicados — automáticamente elimina repetidos. (2) Sin orden — no podés acceder por índice (s[0] da error). (3) Pertenencia O(1) — verificar si un elemento está es instantáneo, sin importar el tamaño del set. En una lista de 1 millón de elementos, buscar con in recorre toda la lista (O(n)). En un set, es O(1).

¿Para qué sirven en análisis de datos?

Deduplicar: unicos = set(lista_con_duplicados) — elimina duplicados al instante. ¿Cuántos clientes únicos hay? len(set(lista_clientes))
Buscar rápido: si tenés una lista negra de CUITs y necesitás verificar millones de transacciones, convertir la lista a set hace la búsqueda 10,000x más rápida.
Comparar grupos: ¿qué clientes tienen tarjeta Y préstamo? (intersección). ¿Qué clientes tienen tarjeta PERO NO préstamo? (diferencia). Sets resuelven esto en una línea.
Validar datos: ¿todos los valores de una columna están en una lista de valores permitidos? Sets te dan la respuesta instantánea.

Analogía: pensá en un set como la lista de asistencia de una reunión. Si alguien firma dos veces, no cuenta doble — el nombre aparece una sola vez. Y para ver si alguien asistió, no necesitás recorrer toda la lista: buscás directamente por su nombre.

Operaciones de conjuntos

Los sets soportan las operaciones matemáticas clásicas de teoría de conjuntos. Esto es extremadamente poderoso para análisis de datos:

Operación	Operador	Método	Resultado
Unión	`A \| B`	`A.union(B)`	Elementos que están en A O en B (o ambos)
Intersección	`A & B`	`A.intersection(B)`	Elementos que están en A Y en B
Diferencia	`A - B`	`A.difference(B)`	Elementos que están en A pero NO en B
Diferencia simétrica	`A ^ B`	`A.symmetric_difference(B)`	Elementos que están en A o B, pero NO en ambos
Subconjunto	`A <= B`	`A.issubset(B)`	True si todos los elementos de A están en B

Caso real en banca: tenés el set de clientes con tarjeta de crédito y el set con préstamo personal. tarjeta & prestamo te da los que tienen ambos productos (cross-sell existente). tarjeta - prestamo te da a quiénes ofrecerles un préstamo (oportunidad de cross-sell). Esto se resuelve con pandas también, pero el concepto de base son sets.

Mutabilidad y frozenset

Los sets normales son mutables: podés agregar con .add() y eliminar con .remove() o .discard(). La diferencia entre remove y discard: remove da error si el elemento no existe; discard no.

frozenset es la versión inmutable: una vez creado, no se puede modificar. Se puede usar como clave de diccionario o como elemento de otro set.

Error común: crear un set vacío con {}. Eso crea un DICCIONARIO vacío. Para un set vacío usá set(). Es una trampa de sintaxis de Python que confunde a todos al principio.

Tip de performance: si necesitás hacer muchas verificaciones de pertenencia (¿este ID está en mi lista?), SIEMPRE convertí la lista a set primero. if id in lista_de_10mil es lento. if id in set_de_10mil es instantáneo. Esta optimización puede transformar un script de minutos a segundos.

Ejemplos explicados paso a paso

Ejemplo 1: Crear sets y deduplicar

ejemplo_01_crear.pyPython

# Crear sets — los duplicados se eliminan automáticamente
numeros = {1, 2, 3, 2, 1, 4, 3, 5}
print(f"Set: {numeros}")  # {1, 2, 3, 4, 5}

# Deduplicar una lista
clientes_con_repetidos = ["García", "López", "García", "Pérez", "López", "García", "Sosa"]
print(f"\nLista original: {len(clientes_con_repetidos)} elementos")
clientes_unicos = set(clientes_con_repetidos)
print(f"Set (únicos): {len(clientes_unicos)} elementos → {clientes_unicos}")

# Contar valores únicos (muy común en análisis)
ciudades = ["BsAs", "Córdoba", "BsAs", "Rosario", "BsAs", "Córdoba", "Mendoza", "BsAs"]
print(f"\nCiudades únicas: {len(set(ciudades))}")
print(f"Cuáles: {set(ciudades)}")

# Set vacío — ¡CUIDADO con {}!
set_vacio = set()     # ✅ correcto
dict_vacio = {}       # ❌ esto es un dict, no un set
print(f"\nset(): {type(set_vacio).__name__}")
print(f"{{}}: {type(dict_vacio).__name__}")

Hacé clic en ▶ Ejecutar

Ejemplo 2: Operaciones de conjuntos

Resolvé preguntas de negocio con operaciones de conjuntos.

ejemplo_02_operaciones.pyPython

# Clientes por producto
tarjeta = {"García", "López", "Martínez", "Pérez", "Fernández"}
prestamo = {"López", "Pérez", "Sosa", "Luna", "Martínez"}
plazo_fijo = {"García", "Pérez", "Luna"}

# UNIÓN: todos los clientes (con al menos un producto)
todos = tarjeta | prestamo | plazo_fijo
print(f"Total clientes únicos: {len(todos)} → {todos}")

# INTERSECCIÓN: clientes con tarjeta Y préstamo
ambos = tarjeta & prestamo
print(f"\nTarjeta Y Préstamo: {ambos}")

# Los tres productos
tres = tarjeta & prestamo & plazo_fijo
print(f"Los tres productos: {tres}")

# DIFERENCIA: tienen tarjeta pero NO préstamo (oportunidad de venta)
oportunidad = tarjeta - prestamo
print(f"\nOportunidad cross-sell (tarjeta sin préstamo): {oportunidad}")

# DIFERENCIA SIMÉTRICA: tienen uno u otro, pero NO ambos
exclusivos = tarjeta ^ prestamo
print(f"Solo un producto (tarjeta XOR préstamo): {exclusivos}")

# SUBCONJUNTO: ¿todos los de plazo fijo tienen tarjeta?
print(f"\n¿Plazo fijo ⊆ Tarjeta? {plazo_fijo <= tarjeta}")
print(f"¿Plazo fijo ⊆ Todos? {plazo_fijo <= todos}")

Hacé clic en ▶ Ejecutar

Ejemplo 3: Agregar, eliminar y modificar

ejemplo_03_modificar.pyPython

# Agregar elementos
clientes = {"García", "López"}
clientes.add("Pérez")         # Agrega uno
clientes.add("García")        # Ya existe → lo ignora
print(f"Después de add: {clientes}")

# Agregar múltiples
clientes.update(["Sosa", "Luna", "García"])  # update con iterable
print(f"Después de update: {clientes}")

# Eliminar
clientes.remove("Sosa")       # Elimina. KeyError si no existe
clientes.discard("NoExiste")   # Elimina. NO da error si no existe
print(f"Después de eliminar: {clientes}")

eliminado = clientes.pop()     # Elimina y devuelve uno aleatorio
print(f"Pop eliminó: {eliminado}")

# Copiar
copia = clientes.copy()
copia.add("NuevoCliente")
print(f"\nOriginal: {clientes}")
print(f"Copia: {copia}")  # La copia es independiente

# Vaciar
copia.clear()
print(f"Después de clear: {copia}")
print(f"Largo: {len(copia)}")

Hacé clic en ▶ Ejecutar

Ejemplo 4: Pertenencia O(1) vs O(n) — performance real

Demostramos que buscar en un set es instantáneo vs buscar en una lista.

ejemplo_04_performance.pyPython

import time

# Crear lista y set con 100,000 elementos
datos = list(range(100000))
datos_set = set(datos)

# Buscar el último elemento (peor caso para lista)
objetivo = 99999

# Búsqueda en LISTA
inicio = time.time()
for _ in range(1000):
    _ = objetivo in datos
t_lista = (time.time() - inicio) * 1000

# Búsqueda en SET
inicio = time.time()
for _ in range(1000):
    _ = objetivo in datos_set
t_set = (time.time() - inicio) * 1000

print(f"Buscar en lista (x1000): {t_lista:.1f} ms")
print(f"Buscar en set   (x1000): {t_set:.1f} ms")
print(f"Set es {t_lista/max(t_set, 0.001):.0f}x más rápido")

# Ejemplo práctico: lista negra de CUITs
lista_negra = set(["20-12345678-9", "27-98765432-1", "30-11111111-5"])
cuit_a_verificar = "20-12345678-9"
print(f"\n¿CUIT en lista negra? {cuit_a_verificar in lista_negra}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: Validación de datos con sets

Verificar que los datos estén dentro de valores permitidos — un patrón clásico de calidad de datos.

ejemplo_05_validacion.pyPython

# Valores permitidos para una columna
PROVINCIAS_VALIDAS = {
    "Buenos Aires", "CABA", "Córdoba", "Santa Fe", "Mendoza",
    "Tucumán", "Entre Ríos", "Salta", "Chaco", "Misiones",
    "Corrientes", "Santiago del Estero", "San Juan", "Jujuy",
    "Río Negro", "Neuquén", "Formosa", "Chubut", "San Luis",
    "Catamarca", "La Rioja", "La Pampa", "Santa Cruz",
    "Tierra del Fuego"
}

# Datos que llegaron de un formulario
datos_crudos = ["Buenos Aires", "CABA", "buenos aires", "Bs As",
                "Córdoba", "cordoba", "Santa Fe", "Mendosa"]

# Validar
validos = []
invalidos = []
for d in datos_crudos:
    if d in PROVINCIAS_VALIDAS:
        validos.append(d)
    else:
        invalidos.append(d)

print(f"Válidos ({len(validos)}): {validos}")
print(f"Inválidos ({len(invalidos)}): {invalidos}")

# Los inválidos necesitan limpieza (normalización de texto)
# Esto lo vas a hacer con .str.title() en pandas

# Encontrar valores que están en los datos pero NO en los permitidos
datos_unicos = set(datos_crudos)
no_reconocidos = datos_unicos - PROVINCIAS_VALIDAS
print(f"\nValores no reconocidos: {no_reconocidos}")

Hacé clic en ▶ Ejecutar

Referencia rápida

Operación	Sintaxis	Nota
Crear	`{1, 2, 3}` o `set([1,2,3])`	`{}` crea dict, no set
Set vacío	`set()`	Nunca `{}`
Agregar uno	`s.add(x)`	Ignora si ya existe
Agregar varios	`s.update(iterable)`	Desde lista, set, etc.
Eliminar (error)	`s.remove(x)`	KeyError si no existe
Eliminar (seguro)	`s.discard(x)`	No da error
Pertenencia	`x in s`	O(1) — instantáneo
Unión	`A \| B`	En A o en B
Intersección	`A & B`	En A y en B
Diferencia	`A - B`	En A pero no en B
Dif. simétrica	`A ^ B`	En A o B, no ambos
Subconjunto	`A <= B`	A está contenido en B
Deduplicar lista	`list(set(lista))`	Pierde el orden original

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Deduplicar una lista

Dada ids = [101, 203, 101, 305, 203, 101, 407, 305], encontrá cuántos IDs únicos hay. Debe incluir 4.

ejercicio_01.pyDebe incluir "4"

ids = [101, 203, 101, 305, 203, 101, 407, 305]

# Encontrá los únicos:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Agregar y verificar pertenencia

Creá un set frutas con 3 elementos. Agregá "mango" con .add(). Verificá si "banana" está en el set. Debe incluir True o False.

ejercicio_02.pyDebe incluir True o False

frutas = {"manzana", "naranja", "uva"}

# Agregá mango y verificá banana:

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: Intersección de dos sets

Dados equipo_a = {"García", "López", "Pérez"} y equipo_b = {"López", "Sosa", "García"}, encontrá los que están en ambos equipos. Debe incluir López.

ejercicio_03.pyDebe incluir "García"

equipo_a = {"García", "López", "Pérez"}
equipo_b = {"López", "Sosa", "García"}

# Encontrá la intersección:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Diferencia — encontrar exclusivos

Clientes con tarjeta: {"García","López","Pérez","Sosa"}. Con préstamo: {"López","Luna","Pérez"}. Encontrá los que tienen tarjeta pero NO préstamo (oportunidad de cross-sell). Debe incluir Sosa.

ejercicio_04.pyDebe incluir "Sosa"

tarjeta = {"García", "López", "Pérez", "Sosa"}
prestamo = {"López", "Luna", "Pérez"}

# Tarjeta sin préstamo:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Valores únicos y conteo

Dada operaciones = ["compra","venta","compra","compra","transferencia","venta","compra","retiro"], encontrá cuántos tipos distintos de operación hay y cuáles son. Debe incluir 4.

ejercicio_05.pyDebe incluir "4"

operaciones = ["compra", "venta", "compra", "compra", "transferencia", "venta", "compra", "retiro"]

# Tipos únicos:

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Unión de tres sets

Tenés clientes por sucursal: BsAs = {"A","B","C"}, Córdoba = {"C","D","E"}, Rosario = {"A","E","F"}. Encontrá el total de clientes únicos y los que están en las 3 sucursales. Debe incluir 6.

ejercicio_06.pyDebe incluir "6"

bsas = {"A", "B", "C"}
cordoba = {"C", "D", "E"}
rosario = {"A", "E", "F"}

# Total únicos y clientes en las 3:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Validar datos con set de permitidos

Tenés MONEDAS_VALIDAS = {"ARS","USD","EUR","BRL"}. Validá estas transacciones: ["ARS","USD","GBP","ARS","JPY","EUR"]. Imprimí cuáles son inválidas. Debe incluir GBP.

ejercicio_07.pyDebe incluir "GBP"

MONEDAS_VALIDAS = {"ARS", "USD", "EUR", "BRL"}
transacciones = ["ARS", "USD", "GBP", "ARS", "JPY", "EUR"]

# Encontrá las monedas inválidas:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Análisis de productos por cliente

Creá un diccionario donde las claves son nombres de clientes y los valores son sets de productos. Encontrá quién tiene más productos y cuál es el producto más popular (el que tiene más clientes). Debe incluir popular.

ejercicio_08.pyDebe incluir "popular"

clientes_productos = {
    "García": {"Cuenta", "Tarjeta", "Plazo fijo"},
    "López": {"Cuenta", "Préstamo"},
    "Pérez": {"Cuenta", "Tarjeta", "Préstamo", "Plazo fijo"},
    "Sosa": {"Cuenta"},
}

# Encontrá el que tiene más productos y el producto más popular:

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Set comprehension

Dada montos = [1500, -200, 3000, 1500, -200, 4500, 3000], creá un set comprehension con solo los montos positivos únicos y calculá su suma. Debe incluir 9000.

ejercicio_09.pyDebe incluir "9000"

montos = [1500, -200, 3000, 1500, -200, 4500, 3000]

# Set comprehension con positivos únicos:

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Análisis completo de cross-sell bancario

Tenés 4 sets de clientes por producto: cuenta_corriente, tarjeta_credito, prestamo_personal, plazo_fijo. Generá un reporte que incluya: total de clientes únicos, clientes con los 4 productos, clientes con solo cuenta (sin ningún otro producto), y la oportunidad de cross-sell más grande (el par de productos con más clientes que tienen uno pero no el otro). Debe incluir CROSS-SELL.

ejercicio_10_desafio.pyDebe incluir "CROSS-SELL"

cuenta = {"García", "López", "Martínez", "Pérez", "Fernández", "Sosa", "Luna"}
tarjeta = {"García", "López", "Pérez", "Fernández"}
prestamo = {"López", "Martínez", "Sosa"}
plazo_fijo = {"García", "Pérez", "Luna"}

# Reporte completo de cross-sell:
print("=== REPORTE CROSS-SELL ===")

Hacé clic en ▶ Ejecutar

Resumen y conexión

Los sets guardan elementos únicos y desordenados. Se crean con {} o set().
set() para vacío — {} crea un dict, no un set.
Deduplicar: set(lista). Contar únicos: len(set(lista)).
Operaciones de conjuntos: | (unión), & (intersección), - (diferencia), ^ (simétrica).
Buscar con in es O(1) en sets vs O(n) en listas — diferencia abismal en datos grandes.
.add() agrega, .discard() elimina sin error, .remove() elimina con error si no existe.

En la siguiente lección (12 · Métodos de strings) vas a aprender todas las formas de transformar, buscar y formatear texto — habilidades esenciales para limpiar datos del mundo real.

Recursos: Python docs — Sets · Set methods

Hecho con ❤️ por Rodri Gonzalez