Guía definitiva de la función map de Python para el procesamiento de datos

Introducción

Podemos usar la función incorporada de Python map() para aplicar una función a cada elemento en un iterable (como una lista o un diccionario) y devolver un nuevo iterador para recuperar los resultados. map() devuelve un objeto de mapa (un iterador), que podemos usar en otras partes de nuestro programa. También podemos pasar el objeto de mapa a la función list(), o a otro tipo de secuencia, para crear un iterable.

La sintaxis de la función map() es la siguiente:

map(function, iterable, [iterable 2, iterable 3, ...])

En lugar de usar un for bucle, la función map() proporciona una manera de aplicar una función a cada elemento en un iterable. Por lo tanto, a menudo puede ser más eficiente ya que solo aplica la función un elemento a la vez en lugar de hacer copias de los elementos en otro iterable. Esto es particularmente útil al trabajar en programas que procesan grandes conjuntos de datos. map() también puede tomar múltiples iterables como argumentos para la función enviando un elemento de cada iterable a la función a la vez.

En este tutorial, revisaremos tres formas diferentes de trabajar con map(): con una función lambda, con una función definida por el usuario y finalmente con una función incorporada utilizando múltiples argumentos iterables.

Usando una Función Lambda

El primer argumento de map() es una función, que usamos para aplicar a cada elemento. Python llama a la función una vez por cada elemento en el iterable que pasamos a map() y devuelve el elemento manipulado dentro de un objeto map. Para el primer argumento de la función, podemos pasar una función definida por el usuario o podemos utilizar funciones lambda, particularmente cuando la expresión es menos compleja.

La sintaxis de map() con una función lambda es la siguiente:

map(lambda item: item[] expression, iterable)

Con una lista como la siguiente, podemos implementar una función lambda con una expresión que queremos aplicar a cada elemento de nuestra lista:

numbers = [10, 15, 21, 33, 42, 55]

Para aplicar una expresión a cada uno de nuestros números, podemos usar map() y lambda:

mapped_numbers = list(map(lambda x: x * 2 + 3, numbers))

Aquí declaramos un elemento en nuestra lista como x. Luego añadimos nuestra expresión. Pasamos nuestra lista de números como el iterable para map().

Para recibir los resultados de esto inmediatamente, imprimimos una lista del objeto map:

print(mapped_numbers)

Output
[23, 33, 45, 69, 87, 113]

Hemos utilizado list() para que el objeto map se nos devuelva como una lista, en lugar de un objeto menos legible como: <objeto map en 0x7fc250003a58>. El objeto map es un iterador sobre nuestros resultados, por lo que podríamos recorrerlo con for o podemos usar list() para convertirlo en una lista. Estamos haciendo esto aquí porque es una buena manera de revisar los resultados.

En última instancia, map() es más útil cuando se trabaja con grandes conjuntos de datos, por lo que probablemente trabajaríamos más con el objeto map, y generalmente no estaríamos utilizando un constructor como list() en ellos.

Para conjuntos de datos más pequeños, las comprensiones de listas pueden ser más adecuadas, pero para los propósitos de este tutorial estamos utilizando un conjunto de datos pequeño para demostrar map().

Implementando una Función Definida por el Usuario

De manera similar a un lambda podemos usar una función que hemos definido para aplicarla a un iterable. Mientras que las funciones lambda son más útiles para implementar cuando se trabaja con una expresión de una sola línea, las funciones definidas por el usuario son más apropiadas cuando la expresión crece en complejidad. Además, cuando necesitamos pasar otra pieza de datos a la función que estás aplicando a tu iterable, las funciones definidas por el usuario pueden ser una mejor opción para la legibilidad.

Por ejemplo, en el siguiente iterable, cada elemento es un diccionario que contiene diferentes detalles sobre cada una de nuestras criaturas de acuario:

aquarium_creatures = [
 {"name": "sammy", "species": "shark", "tank number": 11, "type": "fish"},
 {"name": "ashley", "species": "crab", "tank number": 25, "type": "shellfish"},
 {"name": "jo", "species": "guppy", "tank number": 18, "type": "fish"},
 {"name": "jackie", "species": "lobster", "tank number": 21, "type": "shellfish"},
 {"name": "charlie", "species": "clownfish", "tank number": 12, "type": "fish"},
 {"name": "olly", "species": "green turtle", "tank number": 34, "type": "turtle"}
]

Hemos decidido que todas las criaturas del acuario se van a mover al mismo tanque. Necesitamos actualizar nuestros registros para reflejar que todas nuestras criaturas se están moviendo al tanque 42. Para que map() acceda a cada diccionario y a cada par clave:valor en los diccionarios, construimos una función anidada:

def assign_to_tank(aquarium_creatures, new_tank_number):
 def apply(x):
  x["tank number"] = new_tank_number
  return x
 return map(apply, aquarium_creatures)

Definimos una función assign_to_tank() que toma aquarium_creatures y new_tank_number como parámetros. En assign_to_tank() pasamos apply() como la función a map() en la última línea. La función assign_to_tank devolverá el iterador resultante de map().

apply() toma x como argumento, que representa un elemento en nuestra lista: un solo diccionario.

Luego definimos que x es la clave "tank number" de aquarium_creatures y que debe almacenar el new_tank_number pasado. Devolvemos cada elemento después de aplicar el nuevo número de tanque.

Llamamos a assign_to_tank() con nuestra lista de diccionarios y el nuevo número de tanque que queremos reemplazar por cada criatura:

assigned_tanks = assign_to_tank(aquarium_creatures, 42)

Una vez que la función completa, tenemos nuestro objeto map almacenado en la variable assigned_tanks, que convertimos en una lista e imprimimos:

print(list(assigned_tanks))

Recibiremos la siguiente salida de este programa:

Output
[{'name': 'sammy', 'species': 'shark', 'tank number': 42, 'type': 'fish'}, {'name': 'ashley', 'species': 'crab', 'tank number': 42, 'type': 'shellfish'}, {'name': 'jo', 'species': 'guppy', 'tank number': 42, 'type': 'fish'}, {'name': 'jackie', 'species': 'lobster', 'tank number': 42, 'type': 'shellfish'}, {'name': 'charlie', 'species': 'clownfish', 'tank number': 42, 'type': 'fish'}, {'name': 'olly', 'species': 'green turtle', 'tank number': 42, 'type': 'turtle'}]

Hemos asignado el nuevo número de tanque a nuestra lista de diccionarios. Usando una función que definimos, podemos incorporar map() para aplicar la función de manera eficiente en cada elemento de la lista.

Uso de una función incorporada con múltiples iterables

De la misma manera que las funciones lambda o nuestras propias funciones definidas, podemos usar funciones incorporadas de Python con map(). Para aplicar una función con múltiples iterables, pasamos otro nombre de iterable después del primero. Por ejemplo, usando la pow() función que toma dos números para encontrar la potencia del número base al exponente proporcionado.

Aquí tenemos nuestras listas de enteros que nos gustaría usar con pow():

base_numbers = [2, 4, 6, 8, 10]
powers = [1, 2, 3, 4, 5]

A continuación, pasamos pow() como nuestra función en map() y proporcionamos las dos listas como nuestros iterables:

numbers_powers = list(map(pow, base_numbers, powers))

print(numbers_powers)

map() aplicará la función pow() al mismo elemento en cada lista para proporcionar la potencia. Por lo tanto, nuestros resultados mostrarán 2**1, 4**2, 6**3, y así sucesivamente:

Output
[2, 16, 216, 4096, 100000]

Si proporcionáramos a map() un iterable que fuera más largo que el otro, map() dejaría de calcular una vez que alcanza el final del iterable más corto. En el siguiente programa estamos extendiendo base_numbers con tres números adicionales:

base_numbers = [2, 4, 6, 8, 10, 12, 14, 16]
powers = [1, 2, 3, 4, 5]

numbers_powers = list(map(pow, base_numbers, powers))

print(numbers_powers)

Como resultado, nada cambiará en el cálculo de este programa y, por lo tanto, seguirá produciendo el mismo resultado:

Output
[2, 16, 216, 4096, 100000]

Hemos utilizado la función map() con una función incorporada de Python y hemos visto que puede manejar múltiples iterables. También hemos revisado que map() seguirá procesando múltiples iterables hasta que haya alcanzado el final del iterable con la menor cantidad de elementos.

Conclusión

En este tutorial, hemos explorado varios métodos para utilizar la función map() en Python. Ahora tienes la capacidad de usar map() con funciones personalizadas, expresiones lambda y otras funciones incorporadas. Además, map() se puede aplicar a funciones que requieren múltiples iterables, potenciando su versatilidad en tareas de procesamiento de datos.

Para fines de demostración, convertimos los resultados de map() directamente en una lista. En aplicaciones prácticas, el objeto map devuelto puede ser manipulado aún más para adaptarse a necesidades específicas.

Para profundizar tu comprensión de Python, por favor utiliza los siguientes recursos:

• Tutorial de la función map() de Python para ejemplos más detallados y casos de uso.
• Entendiendo los diccionarios en Python para mejorar tu conocimiento sobre las estructuras de datos en Python.
• Funciones de cadena en Python para explorar varias técnicas de manipulación de cadenas.

Estos recursos te proporcionarán una comprensión completa de las capacidades de Python y cómo utilizarlas de manera efectiva en tus proyectos.

Si deseas aprender más sobre Python, consulta nuestra serie Cómo programar en Python y nuestra página de temas de Python. Para aprender más sobre el trabajo con conjuntos de datos en programación funcional, consulta nuestro artículo sobre la filter() función.

Preguntas frecuentes

¿Qué hace map() en Python?

La función map() en Python toma una función y uno o más iterables y devuelve un iterador que aplica la función dada a cada elemento de los iterables proporcionados. En otras palabras, “mapea” la función a través de cada elemento en el iterable. Por ejemplo:

numbers = [1, 2, 3, 4]
squares = map(lambda x: x**2, numbers)

Aquí, squares será un iterador de 1, 4, 9, 16.

¿Cómo se crea un mapa en Python?

Se crea un objeto mapa llamando a la función incorporada map() con una función y al menos un iterable como argumentos. Por ejemplo:

def add_one(x):
    return x + 1

my_list = [1, 2, 3]
mapped = map(add_one, my_list)  # Crea un objeto mapa

Luego puedes iterar sobre el mapeado o convertirlo en una lista para ver los resultados:

print(list(mapped))  # [2, 3, 4]

¿Es lazy el mapa en Python?

Sí, en Python 3, map() devuelve un iterador lazy, lo que significa que no procesa ni almacena todos los resultados en memoria a la vez. En cambio, calcula cada resultado a demanda a medida que iteras sobre él. Esto puede ser más eficiente en memoria, especialmente para conjuntos de datos grandes, pero también significa que no puedes indexar directamente o iterar repetidamente sobre el mismo objeto mapa sin reconstruirlo.

¿Cómo funciona la función map()?

La función map() funciona de la siguiente manera:

1. Proporcionas una función y uno o más iterables.
2. map() recupera un elemento de cada iterable.
3. Llama a la función con estos elementos como argumentos.
4. Devuelve el resultado de esa llamada a la función.
5. Repite este proceso hasta que alguno de los iterables se agote.

Si se proporcionan múltiples iterables, map() se detiene cuando el iterable más corto se agota. Por ejemplo:

numbers = [1, 2, 3]
others = [10, 20, 30]
result = map(lambda x, y: x + y, numbers, others)
print(list(result))  # [11, 22, 33]

¿Debería usar map en Python?

Si deberías usar map() depende de la preferencia personal y la legibilidad:

Pros:

• Puedes ser más conciso en algunos casos.
• Puedes ser ligeramente más rápido que las comprensiones de listas en ciertos escenarios (aunque a menudo no de manera significativa).

Contras:

• El código que utiliza comprensiones de listas o expresiones generadoras suele considerarse más “Pythonic” y más fácilmente legible.
• Los programadores de Python más nuevos pueden encontrar que las comprensiones de listas son más intuitivas.

En resumen, usa map() si hace que tu código sea más claro y directo. De lo contrario, las comprensiones de listas o las expresiones generadoras son una alternativa muy común.

¿Cómo convertir map a cadena en Python?

Un objeto map es un iterador, no una cadena. Si deseas convertir los resultados de una llamada a map() en una cadena, primero necesitas iterar sobre él. Los enfoques comunes incluyen:

• Convertir a una lista y luego a una representación de cadena:

mapped = map(str, [1, 2, 3])
string_representation = str(list(mapped))  # "[‘1’, ‘2’, ‘3’]"

• Unir los resultados si son elementos de cadena:

mapped = map(str, [1, 2, 3])
joined_string = ''.join(mapped)  # "123"

El mejor método depende de si deseas una representación de lista legible por humanos (str(list(...))) o una concatenación de los resultados (''.join(...)).

¿Qué hace map count()?

Los objetos map en Python no tienen un método count() incorporado. El método count() está disponible en listas, cadenas y ciertas otras colecciones. Si deseas contar las ocurrencias de un valor producido por un objeto map, primero debes convertirlo en una lista (lo cual consume el iterador):

mapped = map(lambda x: x*2, [1, 2, 3, 2])
mapped_list = list(mapped)
count_of_4 = mapped_list.count(4)  # 2, porque 2*2=4 aparece dos veces

Si necesitas un conteo sin convertir a una lista, podrías iterar manualmente:

count_of_value = sum(1 for x in map(lambda x: x*2, [1, 2, 3, 2]) if x == 4)

¿Qué hacen map y filter en Python?

• map(function, iterable): Aplica la función a cada elemento del iterable y devuelve un iterador de los resultados.

• filter(function, iterable): Devuelve un iterador de elementos del iterable para los cuales function(element) es Verdadero. Si function es None, devuelve elementos que son verdaderos por sí mismos.

Por ejemplo:

nums = [1, 2, 3, 4, 5]
mapped_nums = map(lambda x: x*2, nums)        # [2, 4, 6, 8, 10]
filtered_nums = filter(lambda x: x > 2, nums) # [3, 4, 5]

map transforma cada elemento, mientras que filter selecciona ciertos elementos basándose en una condición.