Aplicando Funções a Elementos de Sequências com `map()` em Python
Neste guia, você explorará o uso da função `map()` do Python para aplicar uma função específica a cada item de uma estrutura iterável. O Python suporta programação funcional, permitindo tratar funções como objetos, passá-las como argumentos e retorná-las de outras funções.
A função `map()` é uma ferramenta que aceita uma função e um iterável, aplicando a função a cada elemento do iterável. Ao final deste tutorial, você terá conhecimento para substituir loops detalhados e construções de listas por essa função, utilizando diferentes exemplos práticos.
Exemplos Práticos com Listas
Vamos iniciar com um exemplo simples. Considere a lista `numeros`:
numeros = [2, 4, 3, 7]
E a função `potencia_propria()`, que calcula um número elevado a si mesmo (n**n):
def potencia_propria(n):
return n**n
Nosso objetivo é aplicar `potencia_propria()` a cada elemento de `numeros` e gerar uma nova lista.
Utilizando um Loop `for`
Tradicionalmente, usaríamos um loop `for`:
- Percorrer `numeros`.
- Aplicar `potencia_propria()` a cada número.
- Adicionar o resultado a `numeros_potencias`.
numeros_potencias = []
for numero in numeros:
numeros_potencias.append(potencia_propria(numero))
print(numeros_potencias)
O resultado exibirá os números de `numeros`, cada um elevado à sua própria potência: 2², 4⁴, 3³, e 7⁷.
Saída
[4, 256, 27, 823543]
Compreensão de Listas
Podemos simplificar o código com compreensão de listas. A estrutura básica é:
nova_lista = [<expressão de saída> for item in iterável]
Para o nosso exemplo, a expressão equivalente seria:
numeros_potencias = [potencia_propria(numero) for numero in numeros]
print(numeros_potencias)
Que resulta na mesma saída que o loop `for`.
Saída
[4, 256, 27, 823543]
A função `map()` oferece uma alternativa concisa para aplicar uma função a um iterável. Vamos explorar sua sintaxe e uso.
Sintaxe da Função `map()`
A estrutura geral da função `map()` é:
map(função, iterável_1, [iterável_2, ..., iterável_n])
Ela requer pelo menos dois argumentos: uma `função` e um `iterável`. No uso:
- `função`: Uma função Python (definida pelo usuário ou embutida), classe, método, etc.
- `iterável`: Uma lista, tupla, string, etc.
- `map()` aplica a função a cada item do iterável.
O retorno de `map()` é um objeto mapa, que pode ser convertido em lista com `list(map(função, iterável))`, ou em tupla, caso necessário.
Agora que você compreende a sintaxe, vejamos exemplos práticos.
Utilizando `map()` com Funções Definidas pelo Usuário
Exemplo 1: Aplicando `potencia_propria()` a `numeros` usando `map()`:
Importante: passe o nome da função sem parênteses, `potencia_propria` e não `potencia_propria()`.
print(map(potencia_propria, numeros))
<map object at 0x7f7d315c14d0>
Para visualizar o resultado, convertemos o objeto mapa em uma lista:
numeros_potencias = list(map(potencia_propria, numeros))
print(numeros_potencias)
Obtendo o resultado esperado:
Saída
[4, 256, 27, 823543]
Exemplo 2: Convertendo polegadas para centímetros com a função `polegadas_para_cm()`:
def polegadas_para_cm(polegada):
return polegada * 2.54
polegadas = [5.54, 3.4, 1, 25, 8.2]
cms = list(map(polegadas_para_cm, polegadas))
print(cms)
O resultado é a lista com valores em centímetros:
Saída
[14.0716, 8.636, 2.54, 63.5, 20.828]
Utilizando `map()` com Funções Embutidas
Aqui, aplicaremos funções embutidas do Python com `map()`.
Exemplo 1: Convertendo strings para maiúsculas com `str.upper()`:
strings = ['JavaScript', 'Rust', 'Python', 'Go']
strings_maiusculas = list(map(str.upper, strings))
print(strings_maiusculas)
Obtemos uma nova lista com as strings em letras maiúsculas:
Saída
['JAVASCRIPT', 'RUST', 'PYTHON', 'GO']
Exemplo 2: Obtendo o comprimento de strings com `len()`:
comprimentos_strings = list(map(len, strings))
print(comprimentos_strings)
Comprimentos de cada string:
Saída
[10, 4, 6, 2]
Exemplo 3: Utilizando `map()` com tuplas e a função `type()` para verificar os tipos de dados:
casa = (2, 758.5, 'Bangalore')
tipos_elementos = tuple(map(type, casa))
print(tipos_elementos)
Resultado:
Saída
(<class 'int'>, <class 'float'>, <class 'str'>)
Exemplo 4: Usando a função `sqrt()` do módulo `math` para calcular raízes quadradas:
import math
numeros = [30, 90, 34, 45, 97]
raizes_quadradas = list(map(math.sqrt, numeros))
print(raizes_quadradas)
Saída
[5.477225575051661, 9.486832980505138, 5.830951894845301, 6.708203932499369, 9.848857801796104]
Arredondando Números de Ponto Flutuante
Para arredondar os resultados das raízes quadradas, definimos a função `arredondar_2()`:
def arredondar_2(numero):
return round(numero, 2)
Agora, podemos usar a função map com `arredondar_2()` e `raizes_quadradas`:
raizes_arredondadas = list(map(arredondar_2, raizes_quadradas))
print(raizes_arredondadas)
Saída
[5.48, 9.49, 5.83, 6.71, 9.85]
Também podemos aninhar funções `map()`, calculando a raiz e depois arredondando:
raizes_arredondadas = list(map(arredondar_2, list(map(math.sqrt, numeros))))
print(raizes_arredondadas)
O resultado será o mesmo, mas o código aninhado pode ser menos legível. Priorize a clareza.
Funções Lambda com `map()`
As funções lambda são funções anônimas de uma linha. Úteis para ações simples e únicas.
A sintaxe geral é: `lambda argumentos: expressão`.
Exemplo 1: Invertendo strings com uma função lambda:
strings = ['JavaScript', 'Rust', 'Python', 'Go']
strings_invertidas = list(map(lambda x: x[::-1], strings))
print(strings_invertidas)
A expressão `x[::-1]` inverte a string:
Saída
['tpircSavaJ', 'tsuR', 'nohtyP', 'oG']
Exemplo 2: Arredondando raízes quadradas com lambda:
raizes_arredondadas_lambda = list(map(lambda num: round(num, 2), raizes_quadradas))
print(raizes_arredondadas_lambda)
Resultado idêntico ao exemplo com função definida.
Saída
[5.48, 9.49, 5.83, 6.71, 9.85]
`map()` com Múltiplos Iteráveis
Quando a função exige mais de um argumento, `map()` pode trabalhar com múltiplos iteráveis.
Exemplo 1: Calculando áreas de retângulos com a função `area()`:
def area(comprimento, largura):
return comprimento * largura
comprimentos = [4, 8, 10, 18]
larguras = [9, 4, 6, 11]
areas = list(map(area, comprimentos, larguras))
print(areas)
O resultado é o cálculo da área de cada retângulo:
Saída
[36, 32, 60, 198]
Exemplo 2: Calculando logaritmos com `math.log()`:
import math
x = [2, 6, 12, 10]
base = [2, 3, 2, 5]
log_x = list(map(math.log, x, base))
print(log_x)
O cálculo do logaritmo de cada número com a base correspondente:
Saída
[1.0, 1.6309297535714573, 3.5849625007211565, 1.4306765580733933]
Resumo
- `map()` aplica uma função a cada elemento de um ou mais iteráveis. A sintaxe é `map(função, iterável(s))`.
- A função pode ser qualquer função válida em Python.
- Com funções de ‘k’ argumentos, `map()` usa ‘k’ iteráveis.
Continue explorando e aprendendo sobre outras funcionalidades em Python!