Ejercicios de Estructuras de Datos en Python

Ejercicio 1 — Gestión de lista de la compra

Nivel: ⭐ Muy fácil Estructuras: lista

Enunciado

Crea un programa que gestione una lista de la compra. El programa debe permitir añadir productos al final de la lista, mostrar todos los productos numerados y mostrar cuántos productos hay en total. Los productos se introducen uno a uno hasta que el usuario pulse Enter sin escribir nada.

La salida debe verse así:

=== LISTA DE LA COMPRA ===
Añade productos (Enter vacío para terminar)

Producto: leche
Producto: pan
Producto: huevos
Producto: fruta
Producto:

Tu lista de la compra:
1. leche
2. pan
3. huevos
4. fruta

Total: 4 productos

Pistas

• Crea una lista vacía antes del bucle con productos = [].
• Usa while True con break cuando el usuario pulse Enter sin escribir nada. Detecta la entrada vacía comprobando if not producto.strip().
• Para añadir cada producto usa .append().
• Para mostrar la lista numerada usa enumerate(productos, start=1) dentro de un for.
• len(productos) te da el total de productos.

Ejercicio 2 — Estadísticas de una lista de números

Nivel: ⭐ Muy fácil Estructuras: lista

Enunciado

Pide al usuario que introduzca 8 números enteros y guárdalos en una lista. Después calcula y muestra la suma, la media, el número más grande, el número más pequeño, cuántos son positivos, cuántos negativos y cuántos son cero. No uses las funciones max(), min() ni sum() directamente, calcula todo tú mismo con bucles para practicar.

La salida debe verse así:

Introduce 8 números:
Número 1: 5
Número 2: -3
...

=== ESTADÍSTICAS ===
Números:    [5, -3, 8, 0, 12, -1, 7, 4]
Suma:       32
Media:      4.0
Mayor:      12
Menor:      -3
Positivos:  5
Negativos:  2
Ceros:      1

Pistas

• Usa for i in range(1, 9) para pedir exactamente 8 números y añádelos con .append().
• Para calcular la suma acumula con suma += numero en un bucle for.
• Para el mayor empieza con mayor = numeros[0] y compara cada elemento: si numero > mayor actualiza mayor. Igual para el menor.
• Cuenta positivos, negativos y ceros con tres contadores separados que incrementas dentro del bucle según la condición.

Ejercicio 3 — Agenda de contactos con diccionario

Nivel: ⭐⭐ Fácil Estructuras: diccionario

Enunciado

Crea una agenda de contactos usando un diccionario donde la clave es el nombre y el valor es el teléfono. El programa debe permitir añadir contactos, buscar un contacto por nombre, mostrar todos los contactos ordenados alfabéticamente y eliminar un contacto. Implementa un menú con estas cuatro opciones más la de salir.

La salida debe verse así:

=== AGENDA DE CONTACTOS ===
1. Añadir contacto
2. Buscar contacto
3. Ver todos
4. Eliminar contacto
5. Salir

Opción: 3

Contactos (4):
  Ana García      → 612 345 678
  Carlos López    → 698 765 432
  María Ruiz      → 655 111 222

Pistas

• Declara agenda = {} antes del menú.
• Para añadir: agenda[nombre] = telefono.
• Para buscar usa .get(nombre, "No encontrado") en lugar de acceso directo para evitar errores.
• Para mostrar ordenado usa for nombre, telefono in sorted(agenda.items()). sorted() sobre .items() ordena por la clave automáticamente.
• Para eliminar comprueba primero if nombre in agenda y luego usa del agenda[nombre] o agenda.pop(nombre).

Ejercicio 4 — Analizador de texto con conjuntos

Nivel: ⭐⭐ Fácil Estructuras: lista, conjunto

Enunciado

Pide al usuario que introduzca una frase y analízala usando listas y conjuntos. Muestra cuántas palabras tiene en total, cuántas palabras únicas hay, cuáles son las palabras repetidas y cuántas veces aparece cada palabra. Ignora las diferencias entre mayúsculas y minúsculas.

La salida debe verse así:

Introduce una frase: el gato y el perro y el pájaro y el gato

Total palabras:    9
Palabras únicas:   5
Palabras repetidas: {'el', 'y', 'gato'}

Frecuencia de palabras:
  el      → 4 veces
  gato    → 2 veces
  y       → 3 veces
  perro   → 1 vez
  pájaro  → 1 vez

Pistas

• Convierte la frase a minúsculas con .lower() y divídela en palabras con .split(). Guarda el resultado en una lista.
• Para las palabras únicas convierte la lista a conjunto: unicas = set(palabras). Un conjunto elimina duplicados automáticamente.
• Para encontrar las repetidas crea un diccionario de frecuencias: recorre la lista y para cada palabra haz frecuencia[palabra] = frecuencia.get(palabra, 0) + 1.
• Las palabras repetidas son las que tienen frecuencia mayor que 1. Puedes obtenerlas con una comprensión de conjunto: {p for p, c in frecuencia.items() if c > 1}.

Ejercicio 5 — Gestión de notas con listas de diccionarios

Nivel: ⭐⭐ Fácil Estructuras: lista de diccionarios

Enunciado

Crea un registro de alumnos donde cada alumno es un diccionario con nombre, una lista de notas y la media calculada automáticamente. El programa permite añadir alumnos con sus notas, mostrar el listado completo ordenado por media descendente, mostrar el alumno con mejor y peor media y filtrar los alumnos que han suspendido (media menor de 5).

La salida debe verse así:

=== REGISTRO DE ALUMNOS ===
Alumno: Ana García
Notas (separadas por espacios): 8.5 9.0 7.8 9.2
✓ Ana García añadida. Media: 8.62

...

RANKING POR MEDIA:
1º  Ana García       [8.5, 9.0, 7.8, 9.2]   media: 8.62
2º  María Ruiz       [7.5, 6.0, 8.0]         media: 7.17
3º  Carlos López     [4.8, 5.5, 4.2]         media: 4.83

Mejor alumno:  Ana García (8.62)
Peor alumno:   Carlos López (4.83)

Alumnos suspensos:
  Carlos López → 4.83

Pistas

• Cada alumno es un diccionario: {"nombre": nombre, "notas": notas, "media": media}.
• Para recoger las notas pide una línea de texto y usa .split() para separar y una comprensión de lista para convertir a float: [float(n) for n in entrada.split()].
• Calcula la media con sum(notas) / len(notas) y redondea con round(..., 2).
• Para ordenar por media usa sorted(alumnos, key=lambda a: a["media"], reverse=True).
• Para el mejor y peor usa max(alumnos, key=lambda a: a["media"]) y min(...).

Ejercicio 6 — Comparador de listas con conjuntos

Nivel: ⭐⭐⭐ Intermedio Estructuras: lista, conjunto

Enunciado

Crea un programa que compare las asignaturas de dos alumnos. Pide las asignaturas de cada alumno (separadas por comas) y muestra las asignaturas que tienen en común, las que solo tiene el primero, las que solo tiene el segundo, todas las asignaturas entre los dos (sin repetir) y si alguno tiene todas las asignaturas del otro incluidas.

La salida debe verse así:

Asignaturas de Ana (separadas por comas): matemáticas, física, historia, lengua, arte
Asignaturas de Carlos (separadas por comas): física, química, historia, inglés

=== COMPARACIÓN ===
Asignaturas de Ana (5):    {matemáticas, física, historia, lengua, arte}
Asignaturas de Carlos (4): {física, química, historia, inglés}

En común:          física, historia
Solo Ana tiene:    matemáticas, lengua, arte
Solo Carlos tiene: química, inglés
Entre los dos:     matemáticas, física, historia, lengua, arte, química, inglés

¿Ana tiene todas las de Carlos?   No
¿Carlos tiene todas las de Ana?   No

Pistas

• Lee las asignaturas con input(), divide por coma con .split(",") y limpia espacios con una comprensión: {a.strip().lower() for a in entrada.split(",")}. Directamente crea un conjunto.
• Para las operaciones usa los operadores de conjuntos: & para intersección, - para diferencia, | para unión.
• Para comprobar si uno contiene todas las del otro usa el operador <=: asig_carlos <= asig_ana es True si todas las asignaturas de Carlos están en las de Ana.
• Para mostrar las asignaturas ordenadas convierte el conjunto a lista ordenada: sorted(conjunto).

Ejercicio 7 — Inventario de tienda

Nivel: ⭐⭐⭐ Intermedio Estructuras: lista de diccionarios, diccionario

Enunciado

Crea un sistema de inventario con un menú completo. Los productos tienen nombre, precio, stock y categoría. El sistema permite añadir productos, actualizar stock (sumar o restar unidades), buscar por nombre o categoría, mostrar el inventario ordenado por precio y mostrar un resumen con el valor total del inventario y los productos con stock bajo (5 unidades o menos).

La salida debe verse así:

=== INVENTARIO ===
1. Añadir producto
2. Actualizar stock
3. Buscar producto
4. Ver inventario
5. Resumen
6. Salir

Opción: 4

INVENTARIO (ordenado por precio):
Nombre              Categoría       Precio    Stock
────────────────────────────────────────────────────
Ratón inalámbrico   Periféricos     49.99€      15
Teclado mecánico    Periféricos    129.99€       3 ⚠
Monitor 27"         Informática    449.99€       8
Laptop Pro          Informática   1299.99€       5 ⚠

RESUMEN:
Valor total: 14,874.72 €
Productos con stock bajo (≤5): 2

Pistas

• Guarda los productos en una lista de diccionarios: inventario = []. Cada producto es {"nombre": ..., "precio": ..., "stock": ..., "categoria": ...}.
• Para buscar por nombre o categoría recorre la lista con un for y comprueba si el término buscado está en producto["nombre"].lower() o en producto["categoria"].lower() usando el operador in. Guarda los resultados en una lista nueva.
• Para ordenar por precio usa sorted(inventario, key=lambda p: p["precio"]).
• El valor total es sum(p["precio"] * p["stock"] for p in inventario).
• Marca los productos con stock bajo comparando p["stock"] <= 5 y añadiendo ⚠ en la salida.

Ejercicio 8 — Gestor de grupos y equipos

Nivel: ⭐⭐⭐ Intermedio Estructuras: diccionario de conjuntos, lista

Enunciado

Crea un sistema para gestionar grupos de trabajo. Cada grupo tiene un nombre y un conjunto de miembros. El sistema permite crear grupos, añadir y eliminar miembros, mover un miembro de un grupo a otro, buscar en qué grupo está una persona, mostrar los miembros que están en más de un grupo y fusionar dos grupos en uno nuevo.

La salida debe verse así:

=== GESTOR DE GRUPOS ===
Grupos actuales:
  Backend:   Ana, Carlos, María
  Frontend:  Pedro, Lucía, Ana
  DevOps:    Carlos, Juan, Rosa

Ana está en:      Backend, Frontend
Carlos está en:   Backend, DevOps

Miembros en varios grupos: Ana, Carlos

Fusión Backend + Frontend → FullStack:
  Ana, Carlos, Lucía, María, Pedro

Pistas

• Usa un diccionario donde cada clave es el nombre del grupo y cada valor es un conjunto: grupos = {"Backend": {"Ana", "Carlos", "María"}, ...}.
• Para encontrar en qué grupos está una persona recorre grupos.items() y comprueba if persona in miembros.
• Para mover un miembro de un grupo a otro usa .discard() en el origen y .add() en el destino. Comprueba primero que la persona está en el grupo origen.
• Para encontrar personas en más de un grupo crea una lista con todos los miembros (con repeticiones) usando for miembros in grupos.values(): todos.extend(miembros). Luego busca los que aparecen más de una vez.
• Para fusionar dos grupos usa el operador | de conjuntos: grupos[nuevo] = grupos[g1] | grupos[g2].

Ejercicio 9 — Análisis de ventas

Nivel: ⭐⭐⭐⭐ Difícil Estructuras: lista de diccionarios, diccionario, conjunto

Enunciado

Tienes un registro de ventas ya definido en el código. Escribe funciones para analizarlo y generar un informe completo con: total de ingresos, ventas por categoría de producto (total e importe), mes con más ventas, los 3 productos más vendidos por unidades, clientes únicos que han comprado, clientes que han comprado más de una vez y el ticket medio por cliente.

ventas = [
    {"fecha": "2024-01", "cliente": "Ana",    "producto": "Laptop",   "categoria": "Informatica", "unidades": 1, "precio": 1299.99},
    {"fecha": "2024-01", "cliente": "Carlos", "producto": "Ratón",    "categoria": "Perifericos", "unidades": 2, "precio": 49.99},
    {"fecha": "2024-02", "cliente": "Ana",    "producto": "Monitor",  "categoria": "Informatica", "unidades": 1, "precio": 449.99},
    {"fecha": "2024-02", "cliente": "María",  "producto": "Laptop",   "categoria": "Informatica", "unidades": 1, "precio": 1299.99},
    {"fecha": "2024-02", "cliente": "Carlos", "producto": "Teclado",  "categoria": "Perifericos", "unidades": 1, "precio": 129.99},
    {"fecha": "2024-03", "cliente": "Pedro",  "producto": "Ratón",    "categoria": "Perifericos", "unidades": 3, "precio": 49.99},
    {"fecha": "2024-03", "cliente": "Ana",    "producto": "Teclado",  "categoria": "Perifericos", "unidades": 2, "precio": 129.99},
    {"fecha": "2024-03", "cliente": "María",  "producto": "Monitor",  "categoria": "Informatica", "unidades": 2, "precio": 449.99},
    {"fecha": "2024-03", "cliente": "Lucía",  "producto": "Laptop",   "categoria": "Informatica", "unidades": 1, "precio": 1299.99},
    {"fecha": "2024-03", "cliente": "Carlos", "producto": "Monitor",  "categoria": "Informatica", "unidades": 1, "precio": 449.99},
]

Pistas

• Para el total de ingresos suma v["unidades"] * v["precio"] para cada venta usando sum() con una comprensión.
• Para ventas por categoría recorre la lista y acumula en un diccionario: por_categoria[cat]["importe"] += importe. Usa .setdefault() o defaultdict para inicializar.
• Para el mes con más ventas agrupa los importes por v["fecha"] en un diccionario y luego usa max() con key=lambda x: x[1] sobre .items().
• Para los 3 productos más vendidos agrupa las unidades por producto y usa sorted(..., reverse=True)[:3].
• Para los clientes únicos usa un conjunto: {v["cliente"] for v in ventas}.
• Para los que compraron más de una vez crea un Counter con los clientes y filtra los que tienen conteo mayor que 1.

Ejercicio 10 — Sistema de recomendación sencillo

Nivel: ⭐⭐⭐⭐ Difícil Estructuras: diccionario de conjuntos, lista, conjunto

Enunciado

Implementa un sistema de recomendación de productos basado en lo que compraron otros usuarios con gustos similares. El sistema tiene un historial de compras de varios usuarios. Para un usuario dado debe encontrar los usuarios más similares (los que más productos tienen en común), y recomendar los productos que esos usuarios compraron pero el usuario consultado no tiene todavía. Muestra también el porcentaje de similitud con cada usuario.

historial = {
    "Ana":    {"laptop", "ratón", "teclado", "monitor", "auriculares"},
    "Carlos": {"ratón", "teclado", "webcam", "auriculares", "micrófono"},
    "María":  {"laptop", "monitor", "impresora", "teclado", "ratón"},
    "Pedro":  {"auriculares", "micrófono", "webcam", "altavoces"},
    "Lucía":  {"laptop", "ratón", "teclado", "webcam", "monitor"},
    "Juan":   {"impresora", "tóner", "papel", "ratón"},
}
```

La salida para Ana debe verse así:
```
=== RECOMENDACIONES PARA ANA ===
Productos de Ana: auriculares, laptop, monitor, ratón, teclado

Usuarios similares:
  Lucía   → 4 productos en común (80.0% similitud): laptop, monitor, ratón, teclado
  María   → 4 productos en común (66.7% similitud): laptop, monitor, ratón, teclado
  Carlos  → 2 productos en común (33.3% similitud): auriculares, ratón

Recomendaciones basadas en usuarios similares:
  ⭐ webcam      (lo tienen: Lucía, Carlos)
  ⭐ impresora   (lo tiene:  María)
  ⭐ micrófono   (lo tiene:  Carlos)

Pistas

• Para calcular la similitud entre dos usuarios usa la intersección de sus conjuntos de compras: comunes = historial[u1] & historial[u2]. El porcentaje de similitud es len(comunes) / len(historial[u1] | historial[u2]) * 100. Esto se llama índice de Jaccard.
• Calcula la similitud con todos los demás usuarios menos el propio. Guarda los resultados en una lista de tuplas (usuario, similitud, productos_comunes) y ordénala por similitud descendente. Toma solo los 3 primeros.
• Para las recomendaciones calcula los productos que cada usuario similar tiene pero el usuario consultado no: historial[similar] - historial[usuario]. Acumula todos en un diccionario donde la clave es el producto y el valor es la lista de usuarios que lo tienen.
• Ordena las recomendaciones por número de usuarios que las avalan (los que más usuarios tienen son más relevantes): sorted(recomendaciones.items(), key=lambda x: len(x[1]), reverse=True).
• Filtra para no incluir usuarios con 0 productos en común antes de calcular recomendaciones.