Cómo practicar con estos ejercicios de diccionarios
Necesitas conocer los diccionarios, el método get y el bucle for.
- Lee el contrato: qué recibe la función y qué debe devolver.
- Escribe la función y añade debajo las comprobaciones.
- Ejecuta ambas partes. Un
assertque pasa no imprime nada; si falla, apareceAssertionError. - Antes de abrir la solución, anota qué contiene el diccionario después de procesar la primera clave y la segunda.
Cada solución usa return. Mostrar un valor con print no sustituye al resultado que espera recibir quien llama a la función.
Todas las soluciones incluyen sus pruebas y puedes abrirlas en el editor con el botón «Probar en el editor». Las comprobaciones son educativas y no sustituyen toda la validación de una aplicación real.
Contar y consultar
Cuenta las letras de una palabra
Escribe contar_letras(palabra). Devuelve un diccionario que asocia cada letra con las veces que aparece. contar_letras("casa") es {"c": 1, "a": 2, "s": 1}.
assert contar_letras("casa") == {"c": 1, "a": 2, "s": 1}
assert contar_letras("") == {}
assert contar_letras("aaa") == {"a": 3}Ver una pista para el ejercicio 1
Para cada letra, lee el contador anterior con get(letra, 0) y suma uno.
Ver solución y explicación del ejercicio 1
def contar_letras(palabra):
conteo = {}
for letra in palabra:
conteo[letra] = conteo.get(letra, 0) + 1
return conteo
assert contar_letras("casa") == {"c": 1, "a": 2, "s": 1}
assert contar_letras("") == {}
assert contar_letras("aaa") == {"a": 3}
print("Pruebas superadas")get(letra, 0) evita el KeyError la primera vez que aparece una letra. El diccionario se construye dentro de la función para que cada llamada empiece vacía.
Consulta un dato opcional
Escribe telefono_de(contactos, nombre). contactos es un diccionario de nombre a teléfono. Devuelve el teléfono o "Sin teléfono" si el nombre no está.
agenda = {"Ana": "600", "Leo": "700"}
assert telefono_de(agenda, "Ana") == "600"
assert telefono_de(agenda, "Mia") == "Sin teléfono"
assert "Mia" not in agenda
assert telefono_de({}, "Ana") == "Sin teléfono"Ver una pista para el ejercicio 2
Es un caso en el que la ausencia es normal: get admite un valor alternativo.
Ver solución y explicación del ejercicio 2
def telefono_de(contactos, nombre):
return contactos.get(nombre, "Sin teléfono")
agenda = {"Ana": "600", "Leo": "700"}
assert telefono_de(agenda, "Ana") == "600"
assert telefono_de(agenda, "Mia") == "Sin teléfono"
assert "Mia" not in agenda
assert telefono_de({}, "Ana") == "Sin teléfono"
print("Pruebas superadas")get no añade la clave al diccionario, como comprueba la prueba con "Mia". Con acceso directo, un nombre ausente produciría KeyError.
Transformar diccionarios
Invierte claves y valores
Escribe invertir_diccionario(d). Devuelve un diccionario nuevo en el que los valores pasan a ser claves y las claves valores. Los valores de la entrada son únicos.
assert invertir_diccionario({"a": 1, "b": 2}) == {1: "a", 2: "b"}
assert invertir_diccionario({}) == {}
entrada = {"x": "y"}
assert invertir_diccionario(entrada) == {"y": "x"}
assert entrada == {"x": "y"}Ver una pista para el ejercicio 3
Recorre d.items() para obtener clave y valor a la vez.
Ver solución y explicación del ejercicio 3
def invertir_diccionario(d):
resultado = {}
for clave, valor in d.items():
resultado[valor] = clave
return resultado
assert invertir_diccionario({"a": 1, "b": 2}) == {1: "a", 2: "b"}
assert invertir_diccionario({}) == {}
entrada = {"x": "y"}
assert invertir_diccionario(entrada) == {"y": "x"}
assert entrada == {"x": "y"}
print("Pruebas superadas")items() entrega pares. Si hubiera valores repetidos, el último pisaría a los anteriores: por eso el contrato exige valores únicos.
Fusiona dos diccionarios
Escribe fusionar(a, b). Devuelve un diccionario nuevo con las claves de a y de b. Si una clave está en ambos, gana el valor de b. No modifica a ni b.
a = {"x": 1, "y": 2}
b = {"y": 20, "z": 30}
assert fusionar(a, b) == {"x": 1, "y": 20, "z": 30}
assert a == {"x": 1, "y": 2}
assert b == {"y": 20, "z": 30}
assert fusionar({}, {}) == {}Ver una pista para el ejercicio 4
Empieza con una copia de a y actualiza con los valores de b.
Ver solución y explicación del ejercicio 4
def fusionar(a, b):
resultado = dict(a)
resultado.update(b)
return resultado
a = {"x": 1, "y": 2}
b = {"y": 20, "z": 30}
assert fusionar(a, b) == {"x": 1, "y": 20, "z": 30}
assert a == {"x": 1, "y": 2}
assert b == {"y": 20, "z": 30}
assert fusionar({}, {}) == {}
print("Pruebas superadas")dict(a) crea una copia, así que update no modifica el original. Sin la copia, la prueba de a fallaría.
Agrupar y combinar
Agrupa palabras por longitud
Escribe agrupar_por_longitud(palabras). Devuelve un diccionario cuyas claves son longitudes y cuyos valores son listas con las palabras de esa longitud, en el orden de entrada.
assert agrupar_por_longitud(["sol", "luna", "mar", "tren"]) == {3: ["sol", "mar"], 4: ["luna", "tren"]}
assert agrupar_por_longitud([]) == {}
assert agrupar_por_longitud(["a", "b"]) == {1: ["a", "b"]}Ver una pista para el ejercicio 5
Si la longitud todavía no es una clave, crea la lista vacía antes de añadir. setdefault o una condición sirven.
Ver solución y explicación del ejercicio 5
def agrupar_por_longitud(palabras):
grupos = {}
for palabra in palabras:
largo = len(palabra)
if largo not in grupos:
grupos[largo] = []
grupos[largo].append(palabra)
return grupos
assert agrupar_por_longitud(["sol", "luna", "mar", "tren"]) == {3: ["sol", "mar"], 4: ["luna", "tren"]}
assert agrupar_por_longitud([]) == {}
assert agrupar_por_longitud(["a", "b"]) == {1: ["a", "b"]}
print("Pruebas superadas")Cada valor es una lista que crece. Crear la lista solo cuando falta la clave evita reiniciar el grupo en cada palabra.
Suma importes por categoría
Escribe total_por_categoria(ventas). ventas es una lista de tuplas (categoria, importe). Devuelve un diccionario con el total de cada categoría.
ventas = [("libros", 15), ("juegos", 20), ("libros", 10)]
assert total_por_categoria(ventas) == {"libros": 25, "juegos": 20}
assert total_por_categoria([]) == {}
assert total_por_categoria([("a", 1.5), ("a", 2.5)]) == {"a": 4.0}Ver una pista para el ejercicio 6
Desempaqueta cada tupla en el for y acumula con get(categoria, 0).
Ver solución y explicación del ejercicio 6
def total_por_categoria(ventas):
totales = {}
for categoria, importe in ventas:
totales[categoria] = totales.get(categoria, 0) + importe
return totales
ventas = [("libros", 15), ("juegos", 20), ("libros", 10)]
assert total_por_categoria(ventas) == {"libros": 25, "juegos": 20}
assert total_por_categoria([]) == {}
assert total_por_categoria([("a", 1.5), ("a", 2.5)]) == {"a": 4.0}
print("Pruebas superadas")Es el mismo patrón que contar letras, pero acumulando importes en lugar de unos. Cada categoría tiene su propio acumulador dentro del diccionario.
Errores frecuentes en estos ejercicios
- KeyError al consultar una clave
- Accedes con corchetes a una clave que no existe. Decide si es obligatoria o si su ausencia es normal y usa
geten ese caso. Consulta KeyError. - El contador reinicia en cada vuelta
- Si asignas
conteo[x] = 1siempre, pierdes lo acumulado. Lee el valor anterior conget(x, 0)y suma uno. - Se modifica el diccionario recibido
- Crea un diccionario nuevo o una copia con
dict(original)cuando el contrato pida conservar la entrada. - Se añade una clave sin querer
- Asignar a una clave la crea si no existe. Consultar con
getno añade nada.
Si no entiendes el traceback, empieza por su última línea en la guía de errores de Python.
Preguntas frecuentes sobre ejercicios de diccionarios
¿Cuál es la diferencia entre d[clave] y d.get(clave)?
Con corchetes, una clave ausente produce KeyError; con get obtienes None o el valor alternativo que indiques. Elige según si la ausencia es un error o un caso normal.
¿Importa el orden de las claves?
Los diccionarios conservan el orden de inserción, pero para comparar su contenido dos diccionarios son iguales aunque el orden difiera.
¿Qué hago con claves repetidas al invertir un diccionario?
Que el último valor sustituya a los anteriores. Por eso el contrato del ejercicio exige valores únicos.
Trabaja con texto
Con listas y diccionarios dominados, el texto es el siguiente bloque de práctica.
Practicar strings →Ver los 12 ejercicios de fundamentosFuentes y compatibilidad
Los ejemplos usan Python 3 y la biblioteca estándar. Las instrucciones de instalación se contrastaron con la documentación oficial; los ejemplos de código se verifican con las comprobaciones de estas guías.