map, filter, lambda e compreensões

map e filter: transformar e selecionar

Duas operações aparecem sem parar ao trabalhar com coleções: transformar cada item e selecionar alguns itens. O map cuida da transformação: ele recebe uma função e um iterável, e aplica a função a cada elemento, produzindo os resultados. O filter cuida da seleção: recebe uma função que devolve verdadeiro ou falso e um iterável, e mantém apenas os itens em que a função deu verdadeiro. Ambos devolvem um iterador preguiçoso, então costuma-se envolvê-los em list para ver o resultado de uma vez.

numeros = [1, 2, 3, 4, 5, 6]

# map: transforma cada item (aqui, eleva ao quadrado)
def ao_quadrado(n: int) -> int:
    return n * n

quadrados = list(map(ao_quadrado, numeros))
print(quadrados)  # [1, 4, 9, 16, 25, 36]

# filter: seleciona os pares
def eh_par(n: int) -> bool:
    return n % 2 == 0

pares = list(filter(eh_par, numeros))
print(pares)  # [2, 4, 6]

map aplica ao_quadrado a cada item; filter mantém só os que passam em eh_par.

Nos exemplos, o map transformou cada número no seu quadrado e o filter selecionou apenas os pares. Note que ambos recebem uma função como argumento, o que casa com a ideia de tratar funções como valores. Quando a função é pequena e usada só ali, definir uma função nomeada como ao_quadrado ou eh_par pode ser exagero. É aí que entra o lambda.

lambda: função curta e sem nome

Um lambda é uma função anônima de uma linha. Você escreve a palavra lambda, os parâmetros, dois pontos e a expressão que ela devolve. Não há return: o valor da expressão já é o retorno. O lambda brilha como argumento de map, filter e sorted, onde a função é curta e descartável. Escrever lambda n: n * n no lugar de definir ao_quadrado deixa a intenção junto do uso. Para lógica maior, porém, uma função nomeada de verdade é mais legível e testável.

numeros = [1, 2, 3, 4, 5, 6]

quadrados = list(map(lambda n: n * n, numeros))
print(quadrados)  # [1, 4, 9, 16, 25, 36]

pares = list(filter(lambda n: n % 2 == 0, numeros))
print(pares)  # [2, 4, 6]

# lambda tambem e util como chave de ordenacao:
palavras = ["casa", "oi", "banana"]
print(sorted(palavras, key=lambda p: len(p)))  # ['oi', 'casa', 'banana']

lambda define a função no próprio lugar; ótimo para argumentos curtos de map, filter e sorted.

Compreensão ou map: qual usar

No Python, muitas vezes a compreensão de lista é a forma mais clara de fazer o que map e filter fazem. Elevar ao quadrado os pares, por exemplo, cabe numa única compreensão que transforma e filtra ao mesmo tempo. A comunidade Python tende a preferir a compreensão quando a transformação é simples, porque ela se lê quase como uma frase. O map e o filter ganham espaço quando você já tem uma função nomeada pronta para passar, ou quando encadeia várias transformações e a leitura fica melhor.

numeros = [1, 2, 3, 4, 5, 6]

# Compreensao: transforma e filtra numa linha legivel
quadrados_pares = [n * n for n in numeros if n % 2 == 0]
print(quadrados_pares)  # [4, 16, 36]

# Equivalente com map e filter, mais verboso:
quadrados_pares2 = list(map(lambda n: n * n, filter(lambda n: n % 2 == 0, numeros)))
print(quadrados_pares2)  # [4, 16, 36]

A compreensão une transformação e filtro numa linha; a versão com map e filter é mais verbosa.