Como usar a função Map do Python

Introdução

Podemos usar a função integrada do Python, map(), para aplicar uma função a cada item em um iterável (como uma lista ou um dicionário) e retornar um novo iterador para recuperar os resultados. map() retorna um objeto map (um iterador), que podemos usar em outras partes do nosso programa. Também podemos passar o objeto map à função list(), ou outro tipo de sequência, para criar um iterável.

A sintaxe para a função map() é a seguinte:

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

Em vez de usar um loop for , a função map() fornece uma maneira de aplicar uma função a todos os itens em um iterável. Portanto, muitas vezes ela pode ser mais eficiente, uma vez que ela está aplicando a função apenas a um item de cada vez, em vez de fazer cópias dos itens em outro iterável. Isso é particularmente útil ao trabalhar em programas que processam grandes conjuntos de dados. map() também pode tomar vários iteráveis como argumentos para a função, enviando um item de cada iterável de cada vez para a função.

Neste tutorial, vamos revisar três maneiras diferentes de trabalhar com map(): com uma função lambda, com uma função definida pelo usuário, e finalmente com uma função embutida usando vários argumentos iteráveis.

Usando uma função Lambda

O primeiro argumento para map() é uma função, que usamos para aplicar a cada item. O Python chama a função uma vez para cada item no iterável que passamos para map() e retorna o item manipulado dentro de um objeto map. Como o primeiro argumento da função, podemos passar uma função definida pelo usuário ou fazer uso de funções lambda, particularmente quando a expressão for menos complexa.

A sintaxe de map() com uma função lambda é a seguinte:

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

Com uma lista como a seguinte, podemos implementar uma função lambda com uma expressão que queremos aplicar a cada item em nossa lista:

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

Para aplicar uma expressão contra cada um dos nossos números, podemos usar map() e lambda:

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

Aqui declaramos um item em nossa lista como x. Em seguida, adicionamos nossa expressão. Passamos em nossa lista de números como o iterável para map().

Para receber os resultados disso imediatamente, imprimimos uma lista do objeto map :

print(mapped_numbers) 
Output[23, 33, 45, 69, 87, 113] 

Usamos list() para que o objeto map seja retornado a nós como uma lista, ao invés de um objeto menos legível por humanos, como <map object at 0x7fc250003a58>. O objeto map é um iterador sobre nossos resultados, assim poderíamos fazer loop sobre ele com for ou podemos usar list() para transformá-lo em uma lista. Estamos fazendo isso aqui porque é uma boa maneira de revisar os resultados.

Por fim, map() é mais útil ao trabalhar com grandes conjuntos de dados, então provavelmente trabalharíamos mais com o objeto map e, de maneira geral, não estaríamos usando um construtor como list() neles.

Para conjuntos de dados menores, as list comprehensions podem ser mais adequadas, mas para os propósitos deste tutorial, estamos usando um pequeno conjunto de dados para demonstrar a função map().

Implementando uma função definida pelo usuário

Da mesma forma que o lambda, podemos usar uma função que definimos para aplicar a um iterável. Embora as funções lambda sejam mais úteis para implementar quando você está trabalhando com uma expressão de uma linha, as funções definidas pelo usuário são mais adequadas quando a expressão cresce em complexidade. Além disso, quando precisamos passar outro dado para a função que você está aplicando ao seu iterável, as funções definidas pelo usuário podem ser uma escolha melhor para a legibilidade.

Por exemplo, no seguinte iterável, cada item é um dicionário que contém detalhes diferentes sobre cada uma das nossas criaturas do aquário:

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"} ] 

Decidimos que todas as criaturas do aquário estão na verdade se movendo para o mesmo tanque. Precisamos atualizar nossos registros para refletir que todas as nossas criaturas estão se movendo para o tanque 42. Para que map() acesse cada dicionário e cada par chave:valor neles, construimos uma função aninhada:

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 uma função assign_to_tank() que recebe aquarium_creatures e new_tank_number como parâmetros. Em assign_to_tank() passamos apply() como a função para map() na linha final. A função assign_to_tank retornará o iterador resultante de map().

apply() toma x como um argumento, que representa um item em nossa lista — um único dicionário.

Em seguida, definimos que x é a chave "tank number" de aquarium_creatures e que ele deve armazenar o new_tank_number que foi passado. Retornamos cada item depois de aplicar o novo número do tanque.

Chamamos assign_to_tank() com nossa lista de dicionários e o novo número do tanque que queremos substituir para cada criatura:

assigned_tanks = assign_to_tank(aquarium_creatures, 42) 

Assim que a função tiver sido concluída, temos nosso objeto map armazenado na variável assigned_tanks, que transformamos em uma lista e imprimimos:

print(list(assigned_tanks)) 

Receberemos a seguinte saída deste 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'}] 

Mapeamos o novo número do tanque para nossa lista de dicionários. Usando uma função que definimos, podemos incorporar map() para aplicar a função de forma eficiente em cada item da lista.

Usando uma função integrada com vários iteráveis

Da mesma maneira que as funções lambda ou nossas próprias funções definidas, podemos usar as funções embutidas do Python com map(). Para aplicar uma função com múltiplos iteráveis, passamos outro nome iterável após o primeiro. Por exemplo, usando a função pow() que pega dois números para encontrar a potência do número base ao expoente fornecido.

Aqui temos nossas listas de inteiros que gostaríamos de usar com pow():

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

Em seguida, passamos pow() como nossa função em map() e fornecemos as duas listas como nossos iteráveis:

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

map() irá aplicar a função pow() ao mesmo item em cada lista para fornecer a potência. Portanto, nossos resultados mostrarão 2**1, 4**2, 6**3, e assim por diante:

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

Se pudéssemos fornecer a map() um iterável que fosse mais longo do que o outro, map() pararia de calcular assim que ele atingisse o final daquele mais curto. No programa a seguir, estamos estendendo base_numbers com três números adicionais:

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 será a alterado dentro do cálculo deste programa e assim ele ainda irá produzir o mesmo resultado:

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

Usamos a função map() com uma função integrada do Python e vimos que ela pode lidar com vários iteráveis. Também revisamos que map() continuará a processar vários iteráveis até atingir o final daquele com o menor número de itens.

Conclusão

Neste tutorial, aprendemos as diferentes formas de usar a função map() em Python. Agora, você pode usar map() com sua própria função, uma função lambda, e com quaisquer outras funções integradas. Você também pode implementar map() com funções que exigem vários iteráveis.

Neste tutorial, imprimimos os resultados de map() imediatamente para um formato de lista para fins de demonstração. Em nossos programas, normalmente usaríamos o objeto map retornado para manipular ainda mais os dados.

Se você quiser aprender mais sobre Python, confira nossa série Como programar em Python 3 e nossa página do tópico Python. Para aprender mais sobre como trabalhar com conjuntos de dados em programação funcional, confira nosso artigo sobre a função filter().