Todos los cursos > Informática ( TI ) > Lógica de programación ::

Diccionarios/mapas: modelado con pares clave-valor y acceso por clave

Capítulo 5

Tiempo estimado de lectura: 6 minutos

¿Qué es un diccionario/mapa?

Un diccionario (también llamado mapa) es una estructura de datos que asocia una clave única con un valor. Se modela como pares clave → valor. La idea central es que, si conoces la clave, puedes recuperar (o actualizar) el valor directamente.

id → registro: 1024 → {nombre: "Ana", rol: "admin"}
palabra → frecuencia: "hola" → 7
producto → precio: "pan" → 1.20

En pseudocódigo, un diccionario se suele escribir como {clave1: valor1, clave2: valor2}.

Acceso por índice vs acceso por clave

En una lista, el acceso típico es por índice (posición). En un diccionario, el acceso típico es por clave (identificador). Esta diferencia impacta especialmente en búsquedas y actualizaciones:

Operación	Lista (por índice)	Diccionario (por clave)
Obtener un elemento “conocido”	Rápido si conoces el índice	Rápido si conoces la clave
Buscar por un atributo (ej. id)	Normalmente requiere recorrer hasta encontrar	Si el atributo es la clave, acceso directo
Actualizar un valor	Si no sabes el índice, primero buscas	Actualizas directamente por clave

Regla práctica: si tu operación frecuente es “dado X, obtener Y” y X es único, un diccionario suele ser el modelo natural.

Operaciones esenciales con diccionarios

Crear y asignar

precios = {"pan": 1.20, "leche": 0.95}  # crear con pares iniciales
precios["huevos"] = 2.10                 # agregar o actualizar

Leer por clave

precio_pan = precios["pan"]

Si la clave no existe, muchos lenguajes lanzan error. Por eso es importante el manejo de claves inexistentes (ver más abajo).

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

Actualizar

precios["leche"] = 1.05

Recorrer claves y pares

para cada producto en claves(precios):
    imprimir(producto)

para cada (producto, precio) en items(precios):
    imprimir(producto, precio)

Patrones comunes de uso

1) Contar ocurrencias (frecuencias)

Patrón: recorrer elementos y acumular en un diccionario elemento → conteo.

conteos = {}
para cada palabra en palabras:
    si palabra existe en conteos:
        conteos[palabra] = conteos[palabra] + 1
    si no:
        conteos[palabra] = 1

Variación con valor por defecto (si el lenguaje lo soporta):

conteos[palabra] = obtener(conteos, palabra, 0) + 1

2) Agrupar por categoría

Patrón: categoria → lista de elementos. Útil para agrupar ventas por sucursal, alumnos por curso, tickets por estado, etc.

grupos = {}
para cada item en items:
    cat = item.categoria
    si cat no existe en grupos:
        grupos[cat] = []
    agregar item a grupos[cat]

Resultado esperado: un diccionario donde cada clave es una categoría y el valor es una lista con los elementos de esa categoría.

3) Cachear resultados (memoización simple)

Patrón: guardar resultados de una función costosa para no recalcularlos. Modelo: entrada → salida.

cache = {}

funcion calcular(x):
    si x existe en cache:
        retornar cache[x]
    resultado = operacion_costosa(x)
    cache[x] = resultado
    retornar resultado

Esto acelera llamadas repetidas con la misma entrada, a costa de memoria.

4) Mapear códigos a descripciones

Patrón: codigo → descripcion. Útil para traducir estados, tipos, abreviaturas o códigos de error.

estado = {"P": "Pendiente", "A": "Aprobado", "R": "Rechazado"}
texto = estado["A"]  # "Aprobado"

Decisiones sobre las claves: unicidad, estabilidad y legibilidad

Unicidad

La clave debe identificar unívocamente el valor. Si dos elementos comparten la misma clave, uno sobrescribirá al otro. Por ejemplo, si usas nombre como clave para personas, podrías colisionar (“Juan” repetido). En ese caso, es mejor un id o una clave compuesta.

Estabilidad

Elige claves que no cambien con frecuencia. Si la clave cambia, “pierdes” el acceso directo y debes reinsertar con la nueva clave. Ejemplo: un email puede cambiar; un id interno suele ser más estable.

Legibilidad

Claves legibles facilitan depuración y mantenimiento (por ejemplo, "AR" vs 32 para país). Si necesitas claves compactas por rendimiento o tamaño, considera mantener un mapa de traducción (código → descripción) para mostrar información.

Claves compuestas

Cuando una sola propiedad no identifica, puedes combinar varias. Según el lenguaje, se puede usar una tupla/registro como clave o concatenar con un separador.

# ejemplo conceptual
clave = (sucursal_id, fecha)
ventas_por_dia[clave] = total

Manejo de claves inexistentes

Acceder a una clave inexistente es una fuente común de errores. Hay dos estrategias principales: validación y valores por defecto.

1) Validación antes de leer

si "pan" existe en precios:
    imprimir(precios["pan"])
si no:
    imprimir("No hay precio cargado")

2) Obtener con valor por defecto

Útil cuando un valor “neutral” tiene sentido (por ejemplo, conteo 0, lista vacía, acumulado 0).

precio = obtener(precios, "pan", 0.0)
conteo = obtener(conteos, palabra, 0)
lista = obtener(grupos, cat, [])

Precaución: si usas [] como valor por defecto, asegúrate de no compartir accidentalmente la misma lista entre claves (depende del lenguaje y de cómo se implemente el “default”). Un patrón seguro es crear la lista cuando la clave no existe.

Guía práctica paso a paso: de lista de eventos a diccionario de conteos

Objetivo: partir de una lista de eventos (por ejemplo, logs) y producir un diccionario tipo_evento → cantidad. Este ejercicio entrena el patrón de conteo y el manejo de claves inexistentes.

Paso 1: definir la entrada

Imagina una lista donde cada evento tiene al menos un tipo:

eventos = [
  {tipo: "login", usuario: "ana"},
  {tipo: "click", usuario: "ana"},
  {tipo: "login", usuario: "luis"},
  {tipo: "logout", usuario: "ana"},
  {tipo: "click", usuario: "luis"}
]

Paso 2: crear el diccionario acumulador

conteos_por_tipo = {}

Paso 3: recorrer eventos y actualizar el conteo

Versión con validación explícita:

para cada e en eventos:
    t = e.tipo
    si t existe en conteos_por_tipo:
        conteos_por_tipo[t] = conteos_por_tipo[t] + 1
    si no:
        conteos_por_tipo[t] = 1

Versión con valor por defecto:

para cada e en eventos:
    t = e.tipo
    conteos_por_tipo[t] = obtener(conteos_por_tipo, t, 0) + 1

Paso 4: inspeccionar el resultado

# resultado esperado (conceptual)
{
  "login": 2,
  "click": 2,
  "logout": 1
}

Paso 5 (extensión): contar por usuario y por tipo (clave compuesta)

Si quieres un conteo más detallado, puedes usar una clave compuesta (usuario, tipo):

conteos = {}
para cada e en eventos:
    clave = (e.usuario, e.tipo)
    conteos[clave] = obtener(conteos, clave, 0) + 1

Ejercicios propuestos (construcción incremental)

Ejercicio 1: conteo básico por tipo

Entrada: lista de eventos con tipo.
Salida: diccionario tipo → cantidad.
Requisito: no fallar si aparece un tipo nuevo.

Ejercicio 2: agrupar eventos por usuario

Entrada: lista de eventos con usuario.
Salida: diccionario usuario → lista de eventos.
Pista: inicializa la lista cuando la clave no exista.

Ejercicio 3: mapa de códigos

Crea un diccionario codigo_error → mensaje.
Dado un código, devuelve el mensaje; si no existe, devuelve "Error desconocido" usando un valor por defecto.

Ejercicio 4: cache simple

Implementa una función que calcule un resultado (puede ser una operación repetible) y use un diccionario como cache.
Verifica que, al llamar dos veces con la misma entrada, la segunda vez se lea del cache.

Ahora responde el ejercicio sobre el contenido:

¿Cuál es la decisión más adecuada para modelar datos cuando la operación frecuente es “dado X, obtener Y” y X es único?

¡Tienes razón! Felicitaciones, ahora pasa a la página siguiente.

¡Tú error! Inténtalo de nuevo.

Si X es único y la tarea común es obtener o actualizar Y a partir de X, un diccionario permite acceso directo por clave, evitando recorridos típicos de una lista.