Nivel: 1º–2º DAM/DAW o perfil junior en Python
Objetivo global: aprender a generar y leer CSV, calcular sumas por fila y paralelizar tareas con multiprocessing.
Ejercicio 1 · Generar un CSV N×M con números consecutivos
Enunciado
Pide por teclado el número de filas, el número de columnas y la ruta de salida. Genera un archivo CSV donde cada celda contenga un entero consecutivo comenzando en 1 y avanzando por filas. Ejemplo (3×4):
1,2,3,4
5,6,7,8
9,10,11,12
Pistas técnicas
- Usa
pathlib.Pathpara la ruta y un context managerwith open(..., 'w'). - Construye cada fila como lista de cadenas y únelas con
",".join(...). - El valor de cada celda se puede calcular con
i*columnas + (j+1). - Evita la coma final y cuida el salto de línea solo al final de cada fila.
- En Windows, abre con
newline=''para evitar líneas en blanco extra. - (Avanzado) También puedes usar
csv.writerpara una versión más robusta.
Qué se evalúa
- Correcto formato CSV (comas y saltos de línea).
- Parámetros de entrada validados (>0).
- Código claro y sin duplicar lógica.
Errores típicos a evitar
- Confundir el orden de lectura de filas/columnas en los
input. - Escribir una coma al final de cada línea o un
\nextra.
Referencia docente: implementación base y variantes de escritura de filas.
Ejercicio 2 · Leer un CSV y generar otro con la suma por fila
Enunciado
Dado un CSV de números enteros separados por comas, crea un segundo CSV donde cada línea contenga la suma de los números de la fila correspondiente (una suma por línea).
Pistas técnicas
- Lee el archivo de entrada línea a línea,
strip()para limpiar. - Separa columnas con
split(',')y convierte aint. ManejaValueError. - Suma con
sum(...)y escribe cada resultado en una línea del CSV de salida. - Opcional: ignora celdas vacías (
'') y define política para líneas vacías (p. ej., suma 0). - Si lo prefieres, usa una list comprehension:
list(map(int, linea.split(','))).
Qué se evalúa
- Lectura en streaming (no cargar todo si no es necesario).
- Manejo correcto de espacios y valores no numéricos.
- Archivo de salida bien formateado (una suma por línea).
Errores típicos a evitar
- Limpiado incompleto de la línea antes de
split(','). - No controlar la última línea al escribir (salto final).
Referencia docente: flujo completo de limpieza → conversión → suma → salida.
Ejercicio 3 · Multiprocesamiento básico: lanzar N trabajadores
Enunciado
Pide un número N y lanza N procesos que:
- imprimen un saludo con su PID,
- duermen unos segundos,
- imprimen un mensaje de despedida.
El proceso principal debe esperar a que terminen todos.
Pistas técnicas
- Usa
multiprocessing.Process(target=..., args=...). start()para iniciar,join()para esperar.- Muestra el PID con
os.getpid(). - En Windows, imprescindible la guardia:
if __name__ == '__main__': ... - Para estimar cuántos procesos tiene sentido, consulta
cpu_count()(orientativo).
Qué se evalúa
- Correcta creación y sincronización de procesos.
- Mensajería clara (qué hace cada proceso y cuándo termina).
Errores típicos a evitar
- Olvidar
join()(el principal puede terminar antes que los hijos). - No usar
if __name__ == '__main__':en Windows (recursión).
Referencias docentes: ejemplos con
mp.Processy paso de argumentos.
Ejercicio 4 · CSV + Multiprocesamiento: partir trabajo en chunks y guardar salidas parciales
Enunciado
- Carga un CSV de enteros en memoria como una lista de listas.
- Divide esa lista en N trozos (lo más equilibrados posible).
- Lanza N procesos; cada uno suma las filas de su trozo y escribe un CSV parcial con las sumas.
- El principal espera a que todos terminen.
Pistas técnicas
- Crea una función
carga_csv(path)que devuelvalist[list[int]]. - Crea
dividir_lista(data, n)usandoceily slices para trocear. - En el worker, recorre sus filas, calcula sumas y escribe un fichero con nombre único; añade el PID en el nombre para evitar colisiones.
- Crea el directorio de resultados si no existe:
Path(...).mkdir(parents=True, exist_ok=True). - No lances más procesos que filas:
min(n_procesos, len(datos)).
Qué se evalúa
- Separación de responsabilidades (cargar, dividir, trabajar).
- Robustez al escribir resultados (nombres únicos, carpeta creada).
- Sincronización correcta (
join()a todos los procesos).
Errores típicos a evitar
- Generar trozos vacíos cuando
n > len(data)(ajustarn). - Olvidar
newline=''al escribir CSV en Windows. - No controlar el nombre de salida (colisiones).
Referencia docente: diseño de
carga_csv, troceo conceil, workers y nombres con PID.
(Opcional) Reto final · Unificar resultados en un único CSV ordenado
Enunciado
En vez de varios ficheros parciales, crea un proceso recolector que reciba (mediante multiprocessing.Queue) las tuplas (indice_fila, suma) de cada worker y escriba un solo CSV suma_total.csv en el orden original.
Pistas técnicas
- Parte por rangos de índices, no por sublistas sueltas: mantendrás la trazabilidad del orden.
- El recolector bloquea con
q.get()hasta recibir todas las sumas.
Qué se evalúa
- Comunicación entre procesos y preservación del orden global.
- Menos archivos intermedios, pipeline más limpio.
Criterios de corrección (comunes a toda la serie)
- Funcionalidad: el programa hace exactamente lo pedido.
- Robustez: controla entradas inválidas y edge cases (líneas vacías, comas dobles, etc.).
- Calidad de código: nombres claros, funciones pequeñas, comentarios justos.
- E/S: formato CSV correcto, sin comas/saltos extra, uso adecuado de
newline=''en Windows. - Paralelismo (Ej. 3 y 4): sincronización con
join(), no más procesos de los necesarios.
Entregables sugeridos
- Código
.pybien formateado (PEP 8). - Un ZIP con:
src/,datos/(entradas y salidas de prueba) yREADME.mdcon instrucciones de ejecución. - Capturas de pantalla de pruebas (opcional).
Nota para el profesor
Este artículo está alineado con las prácticas de referencia que incluyen:
- Generación de CSV por filas y control fino de comas/saltos.
- Limpieza, conversión y suma por fila en un pipeline claro.
- Plantillas de multiproceso con paso de argumentos y
join(). - División en trozos y escritura de resultados con nombre único por PID.