Procesamiento de Datos en Python: Ejercicios con Diccionarios, Map, Filter y Reduce

Introducción a la Manipulación de Datos con Python

Este documento presenta una serie de ejercicios prácticos en Python, enfocados en la manipulación de datos estructurados mediante diccionarios y el uso de funciones de orden superior como map(), filter() y reduce(). Se exploran diferentes enfoques para resolver problemas comunes de procesamiento de datos, incluyendo el uso de funciones lambda y list comprehensions.

Definición del Diccionario de Mascotas

Se utiliza un diccionario para almacenar información sobre mascotas, donde cada clave es una tupla que contiene el ID de la mascota (idMascota) y el tipo de animal (perro o gato). El valor asociado a cada clave es también una tupla, cuya estructura varía según el tipo de animal:

• Para perros: (peso, altura)
• Para gatos: (peso, raza)

from functools import reduce

# Clave --> Tupla ( idMascota, animal )
# idMascota --> Identificador mascota
# animal --> perro o gato
# Valor --> Tupla perro ( peso, altura ) -- Tupla gato ( peso, raza )
diccionario = { ( 1, "perro") : ( 22, 25), ( 2, "perro") : (16, 73), (3, "gato") : (5, "siamés") ,
                ( 4, "gato") : (4, "callejero") , ( 5, "gato") : (2, "canijo")}

Ejercicios Resueltos

a) Obtener una lista de los ID de mascotas de los perros con más de 50 cm de altura.

Este ejercicio demuestra cómo filtrar y transformar datos utilizando filter() y map() para identificar perros que cumplen una condición específica de altura y extraer sus identificadores.

Solución 1: Usando funciones definidas

def perroAlto(itemDiccionario):
    bResultado = False
    if itemDiccionario[0][1] == "perro" and itemDiccionario[1][1] >= 50:
        bResultado = True
    return bResultado

def obtenerID(itemDiccionario):
    return itemDiccionario[0][0]

objeto_map = map(obtenerID,filter(perroAlto,diccionario.items()))
print ("objeto_map : ", list(objeto_map))

Solución 2: Usando funciones lambda

Una alternativa más concisa es emplear funciones lambda directamente dentro de map() y filter(), lo que reduce la necesidad de definir funciones auxiliares separadas.

objeto_map = map(lambda n:n[0][0],filter(lambda n: n[0][1] == "perro" and n[1][1] >= 50,diccionario.items()))
print ("objeto_map : ", list(objeto_map))

b) Obtener la suma del peso de los gatos.

Este problema ilustra el uso de reduce() para agregar valores después de filtrar los elementos relevantes. Se busca sumar el peso de todos los gatos presentes en el diccionario.

Solución 1: Usando reduce() con map() y filter()

def sumar(x,y):
    return x+y

suma = reduce(sumar,map(lambda n: n[1][0],filter(lambda k: k[0][1]== "gato",diccionario.items())))
print ("Suma: " , suma)

Solución 2: Usando reduce() con una list comprehension

Una forma más "pythónica" de lograr el mismo resultado es combinar reduce() con una list comprehension, que permite filtrar y transformar los datos en un solo paso antes de la reducción.

suma2 = reduce(sumar,[x[1][0] for x in diccionario.items() if x[0][1]== "gato"])
print ("Suma2: " , suma2)

c) Número total de gatos sin usar el método len().

Este ejercicio desafía a contar el número de elementos que cumplen una condición sin recurrir a la función len(). Se logra aplicando un filtro y luego utilizando map() y reduce() para sumar "unos" por cada gato encontrado.

Explicación del proceso:

1. Se aplica un filtro para seleccionar solo las tuplas del diccionario correspondientes a gatos.
2. Mediante map(), se devuelve un 1 por cada tupla de gato, generando una lista como [1, 1, 1].
3. Utilizando reduce(), se suman los 1s de la lista para obtener el total de gatos.

total_gatos = reduce(sumar,map(lambda x: 1, filter(lambda z: z[0][1]=="gato",diccionario.items())))
print("total gatos: ", total_gatos)

d) Obtener una lista con el formato [ [ID, animal, peso, altura/raza], ... ].

Este último ejercicio se centra en la transformación de la estructura de los datos del diccionario a un formato de lista más plano, útil para otras operaciones o visualizaciones.

Solución 1: Usando map() con función lambda

objeto_map = map(lambda x: [ x[0][0], x[0][1],x[1][0],x[1][1] ], diccionario.items())
print ("Transformación del diccionario : ", list(objeto_map))

Solución 2: Usando una list comprehension

La list comprehension ofrece una sintaxis más compacta y a menudo más legible para este tipo de transformaciones.

lista = [ [ x[0][0], x[0][1],x[1][0],x[1][1] ] for x in diccionario.items() ]
print ("Transformación del diccionario 2: ",lista)

Solución 3: Usando map() con función definida

Similar a la primera solución, pero definiendo una función auxiliar para la lógica de transformación, lo que puede mejorar la legibilidad en casos más complejos.

def transformar(itemD):
    return [ itemD[0][0], itemD[0][1], itemD[1][0], itemD[1][1] ]

objeto_map = map(transformar,diccionario.items())
print ("Transformación del diccionario 3: ", list(objeto_map))