Diccionarios en Python: guía con ejemplos y ejercicios

Actualizado el 29 de septiembre de 2026

Un diccionario guarda pares clave-valor: en vez de acceder a un dato por su posición, como en una lista, lo buscas por un nombre. Es la estructura natural para representar un registro (los datos de un alumno, un producto, una configuración) y para contar o agrupar cosas.

En esta guía vas a ver cómo crear y modificar diccionarios, cómo leerlos sin que el programa se caiga cuando falta una clave, cómo recorrerlos y el patrón para contar, que aparece en muchísimos ejercicios.

Crear un diccionario y leer valores

alumno = {"nombre": "Diego", "edad": 20, "carrera": "Ingeniería"}

alumno["nombre"]                    # 'Diego'
alumno.get("correo")                # None (la clave no existe)
alumno.get("correo", "sin correo")  # 'sin correo'
len(alumno)                         # 3

Se escribe entre llaves, con cada par como clave: valor. Las claves suelen ser textos, pero pueden ser números o cualquier valor inmutable. Hay dos formas de leer: alumno["clave"] lanza un error si la clave no existe, y alumno.get("clave") devuelve None o el valor por defecto que le indiques.

Agregar, cambiar y eliminar

alumno["edad"] = 21                  # cambia un valor existente
alumno["correo"] = "diego@mail.cl"   # agrega una clave nueva

del alumno["correo"]                 # elimina la clave
carrera = alumno.pop("carrera")      # elimina y devuelve el valor
# alumno → {'nombre': 'Diego', 'edad': 21}

La misma sintaxis sirve para agregar y para modificar: si la clave existe, se reemplaza el valor; si no, se crea. Cada clave aparece una sola vez en un diccionario.

Recorrer un diccionario

stock = {"manzanas": 10, "peras": 0, "uvas": 25}

for fruta, cantidad in stock.items():
    print(f"{fruta}: {cantidad}")
# manzanas: 10
# peras: 0
# uvas: 25

list(stock.keys())     # ['manzanas', 'peras', 'uvas']
list(stock.values())   # [10, 0, 25]
sum(stock.values())    # 35

Un for directo sobre el diccionario recorre solo las claves; con .items() obtienes clave y valor en cada vuelta, que es lo que casi siempre se necesita. Desde Python 3.7, los diccionarios mantienen el orden en que se agregaron las claves.

in también pregunta por las claves: "peras" in stock es True, pero 10 in stock es False. Para buscar entre los valores, usa 10 in stock.values().

El patrón para contar

Contar cuántas veces aparece cada cosa es uno de los usos más comunes de un diccionario. La clave es el elemento y el valor, su cantidad:

conteo = {}
for letra in "banana":
    conteo[letra] = conteo.get(letra, 0) + 1

print(conteo)  # {'b': 1, 'a': 3, 'n': 2}

conteo.get(letra, 0) devuelve la cantidad actual o 0 si es la primera vez que aparece la letra, y se le suma 1. Sin get, habría que preguntar primero con un if letra in conteo.

Listas de diccionarios

Una lista de diccionarios es la forma típica de representar una tabla: cada diccionario es una fila. Es también el formato en que suelen llegar los datos de una API.

curso = [
    {"nombre": "Ana", "nota": 6.1},
    {"nombre": "Luis", "nota": 4.5},
]

for alumno in curso:
    print(alumno["nombre"], alumno["nota"])

curso[1]["nota"]   # 4.5

Errores comunes

KeyError

alumno["telefono"] lanza KeyError: 'telefono' si la clave no existe. Si la clave puede faltar, usa get(), o revisa antes con if "telefono" in alumno. También es común el KeyError por diferencias de mayúsculas o espacios: "Nombre" y "nombre" son claves distintas.

Borrar claves mientras se recorre

for fruta in stock:
    if stock[fruta] == 0:
        del stock[fruta]
# RuntimeError: dictionary changed size during iteration

No se puede cambiar el tamaño de un diccionario mientras se recorre. Arma uno nuevo con lo que quieres conservar:

stock = {fruta: cantidad for fruta, cantidad in stock.items() if cantidad > 0}
# {'manzanas': 10, 'uvas': 25}

Usar una lista como clave

Las claves tienen que ser inmutables. {["a"]: 1} lanza un TypeError que menciona unhashable type: 'list'. Si necesitas una clave compuesta, usa una tupla: {("santiago", "chile"): 1} sí funciona.

Ejercicios resueltos

Intenta resolver cada ejercicio antes de abrir la solución: equivocarse y corregir es la parte que más enseña.

1.Contar palabras

Escribe una función contar_palabras(texto) que devuelva un diccionario con cuántas veces aparece cada palabra, sin distinguir mayúsculas.

  • contar_palabras("el sol y el mar") → {"el": 2, "sol": 1, "y": 1, "mar": 1}
  • contar_palabras("Hola hola HOLA") → {"hola": 3}
  • contar_palabras("") → {}
Punto de partida
def contar_palabras(texto):
    ...
Ver solución
Solución
def contar_palabras(texto):
    conteo = {}
    for palabra in texto.lower().split():
        conteo[palabra] = conteo.get(palabra, 0) + 1
    return conteo

Es el patrón para contar aplicado a palabras. .lower() va antes de .split() para que "Hola" y "hola" terminen en la misma clave. Con un texto vacío, split() devuelve una lista vacía y el diccionario queda vacío, sin casos especiales.

Python trae collections.Counter, que hace exactamente esto: Counter(texto.lower().split()). Conviene conocerlo, pero también saber escribirlo a mano.

2.Invertir un diccionario

Escribe una función invertir_diccionario(d) que devuelva un diccionario nuevo donde las claves pasen a ser valores y los valores, claves. Si dos claves tienen el mismo valor, se queda la última.

  • invertir_diccionario({"uno": 1, "dos": 2}) → {1: "uno", 2: "dos"}
  • invertir_diccionario({"a": 1, "b": 1}) → {1: "b"}
Punto de partida
def invertir_diccionario(d):
    ...
Ver solución
Solución
def invertir_diccionario(d):
    invertido = {}
    for clave, valor in d.items():
        invertido[valor] = clave
    return invertido

Se recorre con .items() y se guarda cada par al revés. El segundo ejemplo muestra el límite de invertir: como una clave solo puede aparecer una vez, cuando dos valores se repiten, la asignación de la última clave pisa a la anterior. Eso es lo que pide el enunciado, pero en un caso real conviene pensar si se pierde información.

3.Total de gastos por categoría

Escribe una función total_por_categoria(compras) que reciba una lista de compras, cada una con categoria y monto, y devuelva el total gastado en cada categoría.

Ejemplo
compras = [
    {"categoria": "comida", "monto": 12000},
    {"categoria": "transporte", "monto": 3000},
    {"categoria": "comida", "monto": 8500},
]
total_por_categoria(compras)
# → {"comida": 20500, "transporte": 3000}
Punto de partida
def total_por_categoria(compras):
    ...
Ver solución
Solución
def total_por_categoria(compras):
    totales = {}
    for compra in compras:
        categoria = compra["categoria"]
        totales[categoria] = totales.get(categoria, 0) + compra["monto"]
    return totales

Es el mismo patrón que para contar, pero en vez de sumar 1 se suma el monto de cada compra. Combina las dos formas de usar diccionarios de esta guía: cada compra es un registro (se lee con compra["monto"]) y el resultado es un acumulador por clave. Es, en pequeño, lo que hace un GROUP BY en SQL.

Practica Python con ejercicios a tu nivel

En Coditer resuelves ejercicios en el navegador, con tests automáticos que revisan tu código y una IA que te da pistas cuando te atascas. Practicar es gratis.