Guia Definitivo da Função Map do Python para Processamento de Dados

Introdução

A função embutida do Python map() pode ser usada para aplicar uma função a cada item em um iterável (como uma lista ou 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 para a função list(), ou outro tipo de sequência, para criar um iterável.

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

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

Em vez de usar um for loop, a função map() fornece uma maneira de aplicar uma função a cada item em um iterável. Portanto, pode ser frequentemente mais eficiente, uma vez que está aplicando a função um item por 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 aceitar múltiplos iteráveis como argumentos para a função, enviando um item de cada iterável para a função de cada vez.

Neste tutorial, revisaremos 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 múltiplos 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. Para o primeiro argumento da função, podemos passar uma função definida pelo usuário ou podemos utilizar funções lambda, particularmente quando a expressão é 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 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 como uma lista, em vez de um objeto menos legível como: <map object at 0x7fc250003a58>. O objeto map é um iterador sobre nossos resultados, então poderíamos percorrê-lo 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 com o objeto map mais adiante e, geralmente, não estaríamos usando um construtor como list() neles.

Para conjuntos de dados menores, compreensões de lista podem ser mais adequadas, mas para os propósitos deste tutorial estamos usando um conjunto de dados pequeno para demonstrar map().

Implementando uma Função Definida pelo Usuário

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

Por exemplo, no seguinte iterável, cada item é um dicionário que contém diferentes detalhes sobre cada uma de 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, na verdade, vão se mudar para o mesmo tanque. Precisamos atualizar nossos registros para refletir que todas as nossas criaturas estão se mudando para o tanque 42. Para que map() acesse cada dicionário e cada par chave:valor nos dicionários, construímos 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. Na 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() recebe x como argumento, que representa um item na nossa lista — um único dicionário.

Em seguida, definimos que x é a chave "tank number" de aquarium_creatures e que deve armazenar o new_tank_number passado. Retornamos cada item após 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)

Uma vez que a função é 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 Múltiplos Iteráveis

Da mesma forma que as funções lambda ou nossas próprias funções definidas, podemos usar funções integradas do Python com map(). Para aplicar uma função com múltiplos iteráveis, passamos outro nome de iterável após o primeiro. Por exemplo, usando a pow() função que recebe dois números para encontrar a potência do número base em relação 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 para map() e fornecemos as duas listas como nossos iteráveis:

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

print(numbers_powers)

map() 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 fornecermos ao map() um iterável que seja mais longo que o outro, map() parará de calcular assim que atingir o final do iterável 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 mudará dentro do cálculo deste programa e, portanto, ele ainda produzirá o mesmo resultado:

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

Usamos a função map() com uma função embutida do Python e vimos que ela pode lidar com múltiplos iteráveis. Também revisamos que map() continuará a processar múltiplos iteráveis até alcançar o final do iterável com o menor número de itens.

Conclusão

Neste tutorial, exploramos vários métodos de utilização da função map() em Python. Agora você tem a capacidade de usar map() com funções personalizadas, expressões lambda e outras funções embutidas. Além disso, map() pode ser aplicado a funções que requerem múltiplos iteráveis, aumentando sua versatilidade em tarefas de processamento de dados.

Para fins de demonstração, convertimos os resultados de map() diretamente em uma lista. Em aplicações práticas, o objeto map retornado pode ser manipulado ainda mais para atender necessidades específicas.

Para aprofundar seu entendimento sobre Python, por favor, use os seguintes recursos:

• Tutorial da função map() em Python para exemplos e casos de uso mais detalhados.
• Compreender dicionários em Python para aprimorar seu conhecimento sobre estruturas de dados em Python.
• Funções de string em Python para explorar diversas técnicas de manipulação de string.

Esses recursos fornecerão a você uma compreensão abrangente das capacidades do Python e como utilizá-las efetivamente em seus projetos.

Se você deseja aprender mais sobre Python, confira nossa série Como Programar em Python e nossa página de tópicos Python. Para saber mais sobre trabalhar com conjuntos de dados na programação funcional, confira nosso artigo sobre a função filter().

FAQs

O que o map() faz em Python?

A função map() em Python recebe uma função e um ou mais iteráveis e retorna um iterador que aplica a função dada a cada elemento dos iteráveis fornecidos. Em outras palavras, ela “mapeia” a função sobre cada item no iterável. Por exemplo:

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

Aqui, squares será um iterador de 1, 4, 9, 16.

Como você cria um mapa em Python?

Você cria um objeto map chamando a função embutida map() com uma função e pelo menos um iterável como argumentos. Por exemplo:

def add_one(x):
    return x + 1

my_list = [1, 2, 3]
mapped = map(add_one, my_list)  # Cria um objeto map

Você pode então iterar sobre o mapeado ou convertê-lo em uma lista para ver os resultados:

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

O map é preguiçoso em Python?

Sim, no Python 3, map() retorna um iterador preguiçoso, o que significa que não processa ou armazena todos os resultados na memória de uma vez. Em vez disso, calcula cada resultado sob demanda enquanto você itera sobre ele. Isso pode ser mais eficiente em termos de memória, especialmente para grandes conjuntos de dados, mas também significa que você não pode indexar diretamente ou iterar repetidamente sobre o mesmo objeto map sem reconstruí-lo.

Como funciona a função map()?

A função map() funciona da seguinte maneira:

1. Você fornece uma função e um ou mais iteráveis.
2. map() recupera um elemento de cada iterável.
3. Ela chama a função com esses elementos como argumentos.
4. Ela retorna o resultado dessa chamada de função.
5. Repete esse processo até que qualquer um dos iteráveis se esgote.

Se múltiplos iteráveis forem fornecidos, map() para quando o iterável mais curto se esgota. Por exemplo:

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

Devo usar map em Python?

Se você deve usar map() depende da preferência pessoal e da legibilidade:

Prós:

• Pode ser mais conciso em alguns casos.
• Pode ser ligeiramente mais rápido que as compreensões de lista em certos cenários (embora muitas vezes não de forma significativa).

Contras:

• Código que usa compreensões de lista ou expressões geradoras é frequentemente considerado mais “Pythonic” e mais facilmente legível.
• Programadores Python mais novos podem achar as compreensões de lista mais intuitivas.

Em resumo, use map() se isso tornar seu código mais claro e direto. Caso contrário, compreensões de lista ou expressões geradoras são uma alternativa muito comum.

Como converter map para string em Python?

Um objeto map é um iterador, não uma string. Se você quiser converter os resultados de uma chamada map() em uma string, primeiro precisa iterar sobre ele. Abordagens comuns incluem:

• Converter para uma lista e depois para uma representação em string:

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

• Unir os resultados se forem elementos de string:

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

O melhor método depende se você quer uma representação de lista legível por humanos (str(list(...))) ou uma concatenação dos resultados (''.join(...)).

O que faz map count()?

map objetos em Python não possuem um método count() embutido. O método count() está disponível em listas, strings e certas outras coleções. Se você quiser contar as ocorrências de um valor produzido por um objeto map, deve primeiro convertê-lo em uma lista (o que consome o 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 duas vezes

Se você precisar de uma contagem sem converter para uma lista, você pode iterar manualmente:

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

O que map e filter fazem em Python?

• map(function, iterable): Aplica a função a cada elemento do iterável e retorna um iterador dos resultados.

• filter(function, iterable): Retorna um iterador de elementos do iterável para os quais function(element) é True. Se a função for None, retorna elementos que são verdadeiros por si mesmos.

Por exemplo:

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, enquanto filter seleciona certos elementos com base em uma condição.