Diccionarios y sets

Un diccionario guarda pares clave → valor, como un diccionario real: buscas una palabra (clave) y encuentras su definición (valor).

Crear y acceder

persona = {
    "nombre": "Ana",
    "edad": 25,
    "ciudad": "Bogotá",
}

print(persona["nombre"])    # Ana
print(persona["edad"])      # 25

persona["profesion"] = "Ingeniera"   # agregar nueva clave
persona["edad"] = 26                 # actualizar existente
del persona["ciudad"]                # eliminar

El error más famoso: KeyError

Acceder a una clave inexistente lanza excepción:

persona["email"]        # KeyError: 'email' no existe

Las formas seguras:

persona.get("email")          # None (no explota)
persona.get("email", "N/A")   # "N/A" → valor por defecto

if "email" in persona:        # comprobar existencia
    print(persona["email"])

Recorrer un diccionario

precios = {"cafe": 2500, "te": 2000, "cocoa": 3000}

for bebida in precios:                 # recorre las CLAVES
    print(bebida)

for bebida, precio in precios.items(): # clave y valor juntos
    print(f"{bebida}: ${precio}")

print(list(precios.keys()))    # ['cafe', 'te', 'cocoa']
print(list(precios.values()))  # [2500, 2000, 3000]

El patrón más útil del mundo — contar cosas:

conteo = {}
for palabra in ["python", "es", "genial", "python"]:
    conteo[palabra] = conteo.get(palabra, 0) + 1

print(conteo)   # {'python': 2, 'es': 1, 'genial': 1}

Métodos esenciales de diccionarios

Los diccionarios ofrecen métodos completos para inspección, mutación y recuperación segura:

usuario = {"id": 1, "nombre": "Carlos", "rol": "admin"}

# 1. Recuperación segura y por defecto
print(usuario.get("email", "sin_correo@test.com")) # valor por defecto si no existe
# setdefault: devuelve el valor si existe; si no, lo inserta con el default dado
email = usuario.setdefault("email", "soporte@test.com")
print(usuario["email"]) # "soporte@test.com"

# 2. Vistas dinámicas (reflejan cambios en tiempo real)
claves = usuario.keys()      # dict_keys(['id', 'nombre', 'rol', 'email'])
valores = usuario.values()   # dict_values([1, 'Carlos', 'admin', 'soporte@test.com'])
pares = usuario.items()      # dict_items([('id', 1), ('nombre', 'Carlos'), ...])

# 3. Fusión y actualización
usuario.update({"rol": "superadmin", "activo": True}) # fusiona otro dict o pares clave-valor

# 4. Eliminación
rol_eliminado = usuario.pop("rol")         # extrae y devuelve el valor de la clave
ultimo_par = usuario.popitem()             # extrae y devuelve el último par (clave, valor) como tupla
usuario.clear()                            # vacía el diccionario por completo ({})

Sets: sin duplicados y ultra rápidos

Un set es una colección sin orden y sin elementos repetidos:

numeros = {1, 2, 2, 3, 3, 3}
print(numeros)           # {1, 2, 3} → duplicados eliminados

lista = [1, 2, 2, 3]
sin_duplicados = set(lista)   # el truco clásico para deduplicar

vacio = set()     # ¡ojo! {} crea un diccionario VACÍO, no un set

Métodos y operaciones de sets

Los sets implementan tanto métodos con nombre como operadores matemáticos:

frutas = {"manzana", "pera"}

# Agregar y quitar
frutas.add("uva")          # añade un elemento
frutas.update(["mango", "fresa"]) # añade múltiples elementos de un iterable
frutas.remove("pera")      # elimina; lanza KeyError si no existe
frutas.discard("kiwi")     # elimina si existe; NO lanza error si no está
elemento = frutas.pop()    # extrae y devuelve un elemento arbitrario
frutas.clear()             # vacía el set por completo

# Álgebra de conjuntos (operador vs método)
a = {1, 2, 3}
b = {3, 4, 5}

# Unión: todos los elementos
print(a | b)               # {1, 2, 3, 4, 5}
print(a.union(b))

# Intersección: solo los comunes
print(a & b)               # {3}
print(a.intersection(b))

# Diferencia: elementos en 'a' pero no en 'b'
print(a - b)               # {1, 2}
print(a.difference(b))

# Diferencia simétrica: elementos en 'a' o 'b', pero no en ambos
print(a ^ b)               # {1, 2, 4, 5}
print(a.symmetric_difference(b))

# Relaciones y subconjuntos
c = {1, 2}
print(c.issubset(a))       # True (c es subconjunto de a, o c <= a)
print(a.issuperset(c))     # True (a es superconjunto de c, o a >= c)
print(a.isdisjoint({7, 8}))# True (no comparten ningún elemento)

Los sets responden in de forma rapidísima, incluso con millones de elementos. Si vas a hacer muchas búsquedas de pertenencia, usa un set en vez de una lista.

Errores comunes

d = {"a": 1}
d["b"]            # KeyError

s = {1, 2, 3}
s[0]              # TypeError: los sets NO tienen índice (no hay orden)

d = {[1, 2]: "x"} # TypeError: las claves deben ser inmutables
                  # (str, int, tupla sí; listas y dicts no)

Resumen

• Diccionario: clave → valor. Usa .get() para acceder sin riesgo de KeyError
• .items() recorre clave y valor a la vez; .get(clave, 0) + 1 es el patrón de conteo
• Sets: sin duplicados, sin orden, búsquedas in instantáneas
• set(lista) deduplica; |, &, - son unión, intersección y diferencia
• Las claves de un dict deben ser inmutables