Diccionarios y conjuntos

📐 Fundamento

Sintaxis:

precios = {
    "queso": 0.50,
    "revuelta": 0.60,
    "chicharron": 0.60,
}

vacio = {}

Las llaves: clave: valor. Las claves son únicas — si las repetís, gana la última.

Acceder:

precios["queso"]        # 0.50
precios["mole"]          # ❌ KeyError: 'mole'

Acceso seguro con .get:

precios.get("mole")          # None (default)
precios.get("mole", 0.0)     # 0.0 (default custom)

.get nunca lanza error. Útil cuando querés un valor por defecto.

Modificar:

precios["queso"] = 0.55          # actualizar
precios["frijol"] = 0.55          # agregar nueva clave
del precios["chicharron"]         # eliminar

Comprobar pertenencia:

"queso" in precios       # True
"mole" not in precios    # True

in es rápido en dicts — chequea claves directamente sin recorrer.

Iterar:

# Solo claves
for k in precios:
    print(k)

# Solo valores
for v in precios.values():
    print(v)

# Claves y valores juntos
for k, v in precios.items():
    print(f"{k}: ${v:.2f}")

.items() es la forma más útil — siempre que necesités ambos.

📐 Fundamento

Las claves deben ser hashables. Eso significa inmutables (más una propiedad técnica: poder computar un hash estable).

Hashables (válidas como claves):

• int, float, bool, str, tuple (de hashables), frozenset.

No hashables (inválidas):

• list, dict, set — todo lo mutable.

d = {(1, 2): "a", "x": 5}      # OK
d = {[1, 2]: "a"}                # ❌ TypeError: unhashable type: 'list'

Por qué. Si modificás una clave después de meterla, su "posición" interna cambia y el dict ya no la encuentra. Python lo prohíbe directamente para ahorrarte ese bug.

Los valores no tienen restricción: pueden ser cualquier cosa.

📐 Fundamento

setdefault truco útil:

agrupados = {}
for nombre, edad in personas:
    agrupados.setdefault(edad, []).append(nombre)

Mucho más limpio que:

if edad not in agrupados:
    agrupados[edad] = []
agrupados[edad].append(nombre)

Mezclar dicts (Python 3.9+):

a = {"x": 1, "y": 2}
b = {"y": 5, "z": 3}
c = a | b           # {"x": 1, "y": 5, "z": 3}  — b gana en colisión
a |= b              # actualiza a in-place

Comprehensions de dict:

cuadrados = {x: x ** 2 for x in range(10)}
# {0: 0, 1: 1, 2: 4, ..., 9: 81}

# Invertir un dict
inverso = {v: k for k, v in d.items()}

# Filtrar
caros = {nombre: precio for nombre, precio in precios.items() if precio > 0.50}

📐 Fundamento

Un set es una colección sin orden y sin duplicados de elementos hashables.

Sintaxis:

s = {1, 2, 3}
vacio = set()       # ¡no `{}` que es un dict vacío!
de_lista = set([1, 2, 2, 3, 3, 3])    # {1, 2, 3}

Operaciones:

s.add(5)
s.remove(2)        # KeyError si no está
s.discard(2)       # silencioso si no está
2 in s             # rápido
len(s)

Operaciones de conjuntos clásicas:

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

a | b              # unión: {1, 2, 3, 4, 5, 6}
a & b              # intersección: {3, 4}
a - b              # diferencia (en a, no en b): {1, 2}
a ^ b              # diferencia simétrica (en uno o el otro, no ambos): {1, 2, 5, 6}

a.issubset(b)      # ¿a ⊆ b?
a.issuperset(b)    # ¿a ⊇ b?
a.isdisjoint(b)    # ¿no comparten?

Casos de uso:

• Eliminar duplicados. list(set(lista)) — pero pierde orden.
• Pertenencia rápida. if x in set: es $O(1)$, contra $O(n)$ en lista.
• Operaciones de conjuntos. Cuando los datos son matemáticamente conjuntos.

Frozenset. Versión inmutable de set. Hashable → puede ser clave de dict.

fs = frozenset([1, 2, 3])
d = {fs: "valor"}

📐 Fundamento

Hashing es la magia detrás de la velocidad de dicts y sets.

Función hash

hash(x) → un entero. Misma x, mismo hash. Hashes distintos → valores distintos. Mismos hashes → posiblemente mismo valor (colisión).

hash("ana")    # algún entero, p.ej. -3471234567
hash("beto")   # otro entero
hash(42)       # 42 (Python hashea ints a sí mismos)

Tabla hash

Internamente un dict es un array de "huecos" (slots). Para guardar d["clave"] = valor:

1. Calcula hash("clave").
2. Lo reduce a una posición: pos = hash % tamaño_array.
3. Guarda ("clave", valor) en array[pos].

Para buscar d["clave"]:

1. Calcula hash.
2. Va directo a array[pos].
3. Verifica que la clave coincida (por si hay colisión).

Resultado: búsqueda en tiempo constante $O(1)$ promedio. Sin importar si el dict tiene 10 o 10 millones.

Colisiones

A veces dos claves distintas dan el mismo pos. Estrategias:

• Chaining. Cada slot guarda una lista. Si colisionan, se anexan.
• Open addressing. Si el slot está ocupado, prueba el siguiente. Es lo que usa Python.

Cuando la tabla se llena (>2/3 lleno típicamente), Python crece la tabla — operación cara, pero raras veces necesaria. Por eso "amortizado" sigue siendo $O(1)$.

Implicaciones

• No hay orden garantizado (aunque Python 3.7+ mantiene el orden de inserción).
• Las claves deben ser hashables. Por eso no podés usar list como clave.
• hash debe ser estable durante la vida del objeto.

Esto explica todas las restricciones que veías sin entender hasta ahora.