map e filter

map transforma, filter seleciona

map e filter são duas funções de ordem superior que resolvem tarefas muito comuns. map pega uma função e uma coleção e aplica a função a cada item, produzindo uma coleção de resultados transformados. filter pega uma função que responde verdadeiro ou falso e uma coleção, e mantém apenas os itens para os quais a função respondeu verdadeiro. Um transforma, o outro seleciona. Você vai encontrar os dois em código de outras pessoas, então é importante saber ler.

Um detalhe que confunde quem chega agora: no Python 3, map e filter não devolvem uma lista pronta. Eles devolvem um objeto preguiçoso, que só produz cada item quando alguém pede. Isso economiza memória em coleções grandes, mas significa que print de um map mostra algo como map object, não os valores. Para ver o resultado, ou percorrer com um laço, ou envolver com list() para materializar tudo de uma vez.

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

def dobrar(x):
    return x * 2

def eh_par(x):
    return x % 2 == 0

# map: transforma cada item
dobrados = list(map(dobrar, numeros))
print(dobrados)   # [2, 4, 6, 8, 10]

# filter: mantem so os que passam no teste
pares = list(filter(eh_par, numeros))
print(pares)      # [2, 4]

# Sem list(), voce ve o objeto preguicoso:
print(map(dobrar, numeros))  # <map object at 0x...>

map aplica a função a cada item; filter mantém os aprovados. list() materializa.

map, filter ou compreensão de lista?

Aqui vem a parte honesta. Tudo o que map e filter fazem, a compreensão de lista também faz, e quase sempre de forma mais legível para quem lê português e Python. A compreensão junta a transformação e o filtro numa única expressão que se lê quase como uma frase: para cada número, o dobro, se for par. Ela não precisa de list() em volta, não exige uma função nomeada só para transformar e deixa o critério à vista. Por isso, o guia de estilo da comunidade e a maioria do código moderno preferem a compreensão.

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

# Com map + filter + lambda
resultado_a = list(map(lambda x: x * 2, filter(lambda x: x % 2 == 0, numeros)))
print(resultado_a)   # [4, 8, 12]

# Com compreensao de lista (mais clara)
resultado_b = [x * 2 for x in numeros if x % 2 == 0]
print(resultado_b)   # [4, 8, 12]

O mesmo resultado. A compreensão de lista costuma ser mais fácil de ler.

Repare no caso em que map ganha pontos: quando já existe uma função pronta com o nome certo, map(str, numeros) fica limpo e direto, sem lambda. Fora isso, se você se pegar escrevendo map com uma lambda e ainda por cima aninhando um filter, é sinal de que a compreensão vai ler melhor. A regra prática é simples: comece pela compreensão; só troque por map ou filter quando eles deixarem aquele trecho específico mais claro, não menos.

Fixando: transformar e selecionar

Saia desta aula com duas certezas. A primeira: você sabe ler e usar map e filter, incluindo o detalhe do objeto preguiçoso que pede list() para materializar. A segunda, igualmente importante: você sabe que, na maioria dos casos do dia a dia, a compreensão de lista diz a mesma coisa com mais clareza. Conhecer map e filter é essencial para entender código alheio; escolher a compreensão quando ela é mais legível é o que torna o seu próprio código pythônico.