Função map() do Python: Transforme Iteráveis com Exemplos

Name

Soren Atelier

Updated on 10/02/2026

Transformar cada elemento de uma lista é uma das operações mais comuns na programação Python. Você tem uma lista de strings que precisam ser convertidas em inteiros. Uma coluna de preços que deve ser arredondada. Um conjunto de nomes de arquivo que devem ser convertidos para minúsculas. O instinto é escrever um loop for, criar uma lista vazia, adicionar cada resultado e retornar a lista. Funciona, mas é verboso, propenso a erros e enterra a lógica de transformação real dentro de código padrão.

A função embutida map() do Python elimina esse código padrão. Ela recebe uma função e um ou mais iteráveis, aplica a função a cada elemento e retorna um iterador de resultados. Uma linha substitui cinco. O código se lê como uma descrição do que você quer, não como fazer.

Este guia cobre todos os aspectos práticos da função map do Python: a sintaxe básica, combinação de map com lambda e funções embutidas, trabalho com múltiplos iteráveis, comparações de desempenho com list comprehensions e padrões de processamento de dados do mundo real que você usará em código de produção.

Sintaxe Básica do map()

A assinatura da função map() é direta:

map(function, iterable, *iterables)

• function -- um callable que aceita um argumento (ou mais, se você passar múltiplos iteráveis).
• iterable -- a sequência cujos elementos serão passados para function.
• *iterables -- iteráveis adicionais opcionais. Quando fornecidos, function deve aceitar essa quantidade de argumentos.

map() retorna um objeto map, que é um iterador preguiçoso. Ele não computa todos os resultados imediatamente. Em vez disso, produz valores um de cada vez conforme você os consome.

Aqui está o exemplo mais simples possível:

numbers = [1, 2, 3, 4, 5]
squared = map(lambda x: x ** 2, numbers)
 
print(squared)
# <map object at 0x...>
 
print(list(squared))
# [1, 4, 9, 16, 25]

O objeto map não exibe resultados diretamente. Você o converte em uma lista, tupla ou outra coleção, ou itera sobre ele em um loop.

map() com Funções Embutidas

Um dos usos mais limpos de map() é combiná-lo com as funções embutidas do Python. Sem necessidade de lambda -- apenas passe o nome da função diretamente.

Conversão de Tipos com int, float, str

# Converter strings em inteiros
string_numbers = ["10", "20", "30", "40"]
integers = list(map(int, string_numbers))
print(integers)
# [10, 20, 30, 40]
 
# Converter inteiros em floats
values = [1, 2, 3, 4]
floats = list(map(float, values))
print(floats)
# [1.0, 2.0, 3.0, 4.0]
 
# Converter números em strings
ids = [101, 102, 103]
string_ids = list(map(str, ids))
print(string_ids)
# ['101', '102', '103']

Obtendo Comprimentos com len

words = ["Python", "map", "function", "tutorial"]
lengths = list(map(len, words))
print(lengths)
# [6, 3, 8, 8]

Removendo Espaços com str.strip

raw_inputs = ["  hello  ", "  world ", " python  "]
cleaned = list(map(str.strip, raw_inputs))
print(cleaned)
# ['hello', 'world', 'python']

Outras Combinações Úteis com Funções Embutidas

# abs() para valores absolutos
numbers = [-5, 3, -1, 7, -2]
absolutes = list(map(abs, numbers))
print(absolutes)
# [5, 3, 1, 7, 2]
 
# round() para arredondamento (forma de argumento único)
prices = [19.995, 4.123, 99.876]
rounded = list(map(round, prices))
print(rounded)
# [20, 4, 100]
 
# bool() para veracidade
values = [0, 1, "", "hello", None, [], [1]]
truthy = list(map(bool, values))
print(truthy)
# [False, True, False, True, False, False, True]

Quando uma função embutida já faz o que você precisa, passe-a diretamente para map(). Não há razão para envolvê-la em um lambda.

map() com Funções Lambda

Funções lambda desbloqueiam todo o poder de map(). Elas permitem definir transformações inline sem criar uma função nomeada.

# Elevar cada número ao quadrado
numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))
print(squared)
# [1, 4, 9, 16, 25]
 
# Celsius para Fahrenheit
celsius = [0, 20, 37, 100]
fahrenheit = list(map(lambda c: round(c * 9/5 + 32, 1), celsius))
print(fahrenheit)
# [32.0, 68.0, 98.6, 212.0]
 
# Extrair domínio de endereços de e-mail
emails = ["alice@gmail.com", "bob@company.org", "carol@university.edu"]
domains = list(map(lambda e: e.split("@")[1], emails))
print(domains)
# ['gmail.com', 'company.org', 'university.edu']
 
# Formatar nomes
names = ["alice smith", "bob jones", "carol white"]
formatted = list(map(lambda n: n.title(), names))
print(formatted)
# ['Alice Smith', 'Bob Jones', 'Carol White']

O padrão é consistente: map(lambda x: transform(x), iterable). Mantenha o corpo do lambda como uma expressão única e clara. Se a transformação requer múltiplos passos, use uma função nomeada.

map() com Múltiplos Iteráveis

Quando você passa múltiplos iteráveis, map() chama a função com um elemento de cada iterável em paralelo. A função deve aceitar tantos argumentos quantos iteráveis existam. A iteração para quando o iterável mais curto se esgota.

# Somar elementos correspondentes de duas listas
list_a = [1, 2, 3, 4]
list_b = [10, 20, 30, 40]
sums = list(map(lambda a, b: a + b, list_a, list_b))
print(sums)
# [11, 22, 33, 44]
 
# Calcular pontuações ponderadas
scores = [85, 92, 78, 95]
weights = [0.3, 0.3, 0.2, 0.2]
weighted = list(map(lambda s, w: round(s * w, 1), scores, weights))
print(weighted)
# [25.5, 27.6, 15.6, 19.0]
 
# Combinar nomes e sobrenomes
first_names = ["Ada", "Grace", "Alan"]
last_names = ["Lovelace", "Hopper", "Turing"]
full_names = list(map(lambda f, l: f"{f} {l}", first_names, last_names))
print(full_names)
# ['Ada Lovelace', 'Grace Hopper', 'Alan Turing']

Três ou Mais Iteráveis

# Calcular volume a partir de três listas de dimensões
lengths = [2, 3, 4]
widths = [5, 6, 7]
heights = [8, 9, 10]
 
volumes = list(map(lambda l, w, h: l * w * h, lengths, widths, heights))
print(volumes)
# [80, 162, 280]

Lidando com Comprimentos Desiguais

map() para no iterável mais curto. Sem erro, sem preenchimento -- simplesmente para:

a = [1, 2, 3, 4, 5]
b = [10, 20, 30]
result = list(map(lambda x, y: x + y, a, b))
print(result)
# [11, 22, 33]
# Elementos 4 e 5 de 'a' são silenciosamente descartados

Se você precisa lidar com comprimentos desiguais explicitamente, use itertools.zip_longest:

from itertools import zip_longest
 
a = [1, 2, 3, 4, 5]
b = [10, 20, 30]
result = list(map(lambda pair: pair[0] + (pair[1] or 0), zip_longest(a, b, fillvalue=0)))
print(result)
# [11, 22, 33, 4, 5]

map() vs List Comprehension

Esta é a comparação mais importante. Tanto map() quanto list comprehensions transformam sequências, mas têm forças diferentes.

Benchmark de Desempenho

import timeit
 
data = list(range(100_000))
 
# map com função embutida
time_map_builtin = timeit.timeit(
    'list(map(str, data))',
    globals={'data': data},
    number=100
)
 
# List comprehension com função embutida
time_comp_builtin = timeit.timeit(
    '[str(x) for x in data]',
    globals={'data': data},
    number=100
)
 
# map com lambda
time_map_lambda = timeit.timeit(
    'list(map(lambda x: x * 2, data))',
    globals={'data': data},
    number=100
)
 
# List comprehension equivalente
time_comp_expr = timeit.timeit(
    '[x * 2 for x in data]',
    globals={'data': data},
    number=100
)
 
print(f"map + embutida:   {time_map_builtin:.4f}s")
print(f"comprehension:    {time_comp_builtin:.4f}s")
print(f"map + lambda:     {time_map_lambda:.4f}s")
print(f"comprehension:    {time_comp_expr:.4f}s")
# Resultados típicos:
# map + embutida:   ~0.85s (mais rápido)
# comprehension:    ~1.05s
# map + lambda:     ~0.95s
# comprehension:    ~0.80s (mais rápido)

A percepção chave: map() com uma função embutida (como int, str, float) é mais rápido porque evita criar uma chamada de função nível Python em cada iteração. Mas map() com um lambda é aproximadamente a mesma velocidade que -- ou ligeiramente mais lento que -- uma list comprehension, porque ambos envolvem uma chamada de função nível Python por elemento.

map() vs Expressão Geradora

Se você não precisa da lista completa de resultados na memória, tanto map() quanto expressões geradoras fornecem avaliação preguiçosa:

# Objeto map - preguiçoso
mapped = map(lambda x: x ** 2, range(1_000_000))
 
# Expressão geradora - preguiçosa
generated = (x ** 2 for x in range(1_000_000))
 
# Ambos consomem memória apenas durante a iteração
for value in mapped:
    if value > 100:
        break

A diferença é estilística. Expressões geradoras são mais naturais de ler para a maioria dos desenvolvedores Python e suportam filtragem com cláusulas if. Use map() quando já tiver uma função nomeada para aplicar; use uma expressão geradora caso contrário.

# map é limpo quando você tem uma função nomeada
import math
roots = map(math.sqrt, range(10))
 
# Gerador é limpo para expressões
roots = (x ** 0.5 for x in range(10))

Convertendo Objetos map para list, tuple e set

O objeto map é um iterador. Para materializar os resultados, converta-o explicitamente:

numbers = [1, 2, 3, 2, 4, 3, 5]
 
# Para lista (preserva ordem, permite duplicatas)
as_list = list(map(lambda x: x * 10, numbers))
print(as_list)
# [10, 20, 30, 20, 40, 30, 50]
 
# Para tupla (sequência imutável)
as_tuple = tuple(map(lambda x: x * 10, numbers))
print(as_tuple)
# (10, 20, 30, 20, 40, 30, 50)
 
# Para set (remove duplicatas, sem ordem)
as_set = set(map(lambda x: x * 10, numbers))
print(as_set)
# {10, 20, 30, 40, 50}

Importante: Um objeto map só pode ser consumido uma vez. Depois de convertê-lo para lista, iterar novamente não produz nada:

mapped = map(str, [1, 2, 3])
first = list(mapped)
second = list(mapped)
print(first)   # ['1', '2', '3']
print(second)  # [] -- já esgotado

map() com Funções Personalizadas

Para transformações complexas demais para um lambda, defina uma função regular e passe-a para map():

def parse_temperature(reading):
    """Converte uma string de leitura de temperatura em um dict padronizado."""
    value, unit = float(reading[:-1]), reading[-1]
    if unit == 'F':
        celsius = round((value - 32) * 5 / 9, 1)
    elif unit == 'C':
        celsius = value
    elif unit == 'K':
        celsius = round(value - 273.15, 1)
    else:
        raise ValueError(f"Unidade desconhecida: {unit}")
    return {"original": reading, "celsius": celsius}
 
readings = ["98.6F", "37.0C", "310.0K", "72.0F"]
parsed = list(map(parse_temperature, readings))
 
for entry in parsed:
    print(f"{entry['original']} -> {entry['celsius']}°C")
# 98.6F -> 37.0°C
# 37.0C -> 37.0°C
# 310.0K -> 36.9°C
# 72.0F -> 22.2°C

Este padrão mantém as chamadas map() limpas enquanto move lógica complexa para funções testáveis e documentadas.

def normalize_record(record):
    """Padroniza um registro de usuário para inserção no banco de dados."""
    return {
        "name": record["name"].strip().title(),
        "email": record["email"].strip().lower(),
        "age": int(record["age"]),
        "active": record.get("active", True),
    }
 
raw_records = [
    {"name": "  alice smith ", "email": "ALICE@Email.COM", "age": "30"},
    {"name": "bob jones", "email": "Bob@Work.ORG  ", "age": "25"},
]
 
clean_records = list(map(normalize_record, raw_records))
for r in clean_records:
    print(r)
# {'name': 'Alice Smith', 'email': 'alice@email.com', 'age': 30, 'active': True}
# {'name': 'Bob Jones', 'email': 'bob@work.org', 'age': 25, 'active': True}

Encadeando Chamadas map()

Como map() retorna um iterador, você pode encadear múltiplas chamadas map() para construir pipelines de transformação. Cada passo processa um elemento por vez sem criar listas intermediárias:

raw_data = ["  42  ", " 17 ", "  89  ", " 3  "]
 
# Cadeia: remover espaços -> converter para int -> dobrar o valor
result = map(str.strip, raw_data)
result = map(int, result)
result = map(lambda x: x * 2, result)
 
print(list(result))
# [84, 34, 178, 6]

Para melhor legibilidade, você pode aninhar as chamadas (ler de dentro para fora):

raw_data = ["  42  ", " 17 ", "  89  ", " 3  "]
 
result = list(map(lambda x: x * 2, map(int, map(str.strip, raw_data))))
print(result)
# [84, 34, 178, 6]

A versão aninhada é compacta mas mais difícil de ler. A versão sequencial é mais clara para pipelines de múltiplos passos. Nenhuma cria listas intermediárias -- os três objetos map são avaliados preguiçosamente.

map() em Pipelines de Processamento de Dados

O processamento de dados do mundo real frequentemente envolve leitura, limpeza, transformação e agregação de dados. map() se encaixa naturalmente neste padrão.

Processamento de Entradas de Log

log_lines = [
    "2026-02-10 INFO User logged in",
    "2026-02-10 ERROR Database timeout",
    "2026-02-10 WARNING Disk space low",
    "2026-02-10 INFO File uploaded",
]
 
def parse_log(line):
    parts = line.split(" ", 2)
    return {"date": parts[0], "level": parts[1], "message": parts[2]}
 
parsed = list(map(parse_log, log_lines))
errors = list(filter(lambda entry: entry["level"] == "ERROR", parsed))
print(errors)
# [{'date': '2026-02-10', 'level': 'ERROR', 'message': 'Database timeout'}]

Lógica de Renomeação de Arquivos em Lote

import os
 
filenames = ["Report Q1.PDF", "data export.CSV", "NOTES 2026.TXT"]
 
def sanitize_filename(name):
    base, ext = os.path.splitext(name)
    return base.strip().lower().replace(" ", "_") + ext.lower()
 
cleaned = list(map(sanitize_filename, filenames))
print(cleaned)
# ['report_q1.pdf', 'data_export.csv', 'notes_2026.txt']

Pipeline de Dados Numéricos

import math
 
raw_measurements = ["3.14159", "2.71828", "1.41421", "1.73205"]
 
# Pipeline: analisar -> elevar ao quadrado -> logaritmo -> arredondar para 3 decimais
pipeline = map(lambda x: round(x, 3),
           map(math.log,
           map(lambda x: x ** 2,
           map(float, raw_measurements))))
 
print(list(pipeline))
# [2.292, 2.003, 0.693, 1.099]

Quando Usar map() vs List Comprehension: Guia de Decisão

Use esta referência rápida para decidir qual ferramenta se encaixa na sua situação:

Use map() quando:

• Estiver aplicando uma única função embutida: map(int, strings), map(str.strip, lines)
• Já tiver uma função nomeada que faz a transformação
• Quiser avaliação preguiçosa e não precisar da lista completa na memória
• Estiver passando múltiplos iteráveis para operações elemento por elemento

Use uma list comprehension quando:

• A transformação for uma expressão simples: [x * 2 for x in numbers]
• Precisar filtrar no mesmo passo: [x for x in items if x > 0]
• A lógica envolver múltiplas condições ou operações aninhadas
• Quiser o resultado como lista imediatamente
• A legibilidade importar mais que micro-otimização

Use uma expressão geradora quando:

• Precisar de avaliação preguiçosa mas quiser a legibilidade da sintaxe comprehension
• O resultado for consumido apenas uma vez (passado para sum(), max(), join(), etc.)

# map -- mais limpo para conversão de tipos
integers = list(map(int, ["1", "2", "3"]))
 
# List comprehension -- mais limpo para transformação + filtro
even_squares = [x ** 2 for x in range(20) if x % 2 == 0]
 
# Expressão geradora -- mais limpo para consumo de passagem única
total = sum(x ** 2 for x in range(1000))

Experimentando com map() no RunCell

Quando você está construindo pipelines de transformação de dados com map(), testar cada estágio interativamente é essencial. Você precisa ver resultados intermediários, verificar casos extremos e confirmar que maps encadeados produzem a saída esperada.

RunCell (opens in a new tab) é um agente de IA que roda diretamente dentro de notebooks Jupyter. Ele entende o contexto do seu notebook -- as variáveis, DataFrames e imports já na memória -- e ajuda a construir e depurar pipelines map() passo a passo:

• Visualizar resultados intermediários. Peça ao RunCell para mostrar o que cada estágio de um map() encadeado produz, sem quebrar seu pipeline.
• Sugerir alternativas vetorizadas. Se estiver usando map() em Series do pandas, o RunCell pode recomendar operações nativas do pandas 10-100x mais rápidas.
• Converter entre map e comprehension. Descreva a transformação e o RunCell gera ambas as versões para você escolher a mais legível.
• Depurar casos extremos. Alimente entradas inesperadas (valores None, strings vazias, tipos mistos) no seu pipeline map e veja exatamente onde ele quebra.

FAQ

O que a função map() faz em Python?

A função map() aplica uma função dada a cada item em um ou mais iteráveis (como listas, tuplas ou strings) e retorna um iterador dos resultados. É uma função embutida que permite transformação de dados no estilo funcional sem escrever loops explícitos. A sintaxe é map(function, iterable), e o objeto map retornado é preguiçoso -- ele computa resultados sob demanda em vez de todos de uma vez.

map() é mais rápido que um loop for em Python?

Sim, map() é geralmente mais rápido que um loop for equivalente que constrói uma lista com append(). A vantagem de velocidade vem de map() ser implementado em C no nível do interpretador, evitando o overhead da iteração de loop e chamadas de método no nível Python. Ao usar map() com uma função embutida como int ou str, o ganho de desempenho é mais significativo -- tipicamente 20-40% mais rápido. Com um lambda, a diferença diminui porque o lambda introduz uma chamada de função no nível Python.

Como converter um objeto map em lista?

Envolva a chamada map() com list(): result = list(map(int, strings)). Você também pode converter para outras coleções: tuple(map(...)) para tuplas, set(map(...)) para sets. Lembre-se de que um objeto map é um iterador de uso único. Uma vez consumido (ao converter para lista ou iterar), ele está esgotado e não pode ser reutilizado.

map() pode trabalhar com múltiplas listas?

Sim. Passe múltiplos iteráveis após a função: map(func, list1, list2, list3). A função deve aceitar o mesmo número de argumentos que há iteráveis. Por exemplo, list(map(lambda a, b: a + b, [1, 2], [10, 20])) retorna [11, 22]. A iteração para no iterável mais curto, então listas de comprimentos desiguais não geram erros -- elementos extras são silenciosamente ignorados.

Devo usar map() ou list comprehension?

Use map() ao aplicar uma única função existente (embutida ou nomeada) a um iterável, especialmente para conversões de tipo como map(int, strings). Use uma list comprehension quando a transformação envolver uma expressão, quando precisar filtrar com uma cláusula if, ou quando a legibilidade for prioridade. No Python moderno, list comprehensions são a escolha padrão para a maioria dos desenvolvedores, mas map() com funções embutidas continua mais rápido e conciso para transformações simples de uma função.

Conclusão

A função map() do Python é uma ferramenta precisa para um trabalho específico: aplicar uma única função a cada elemento de um iterável sem escrever um loop. Ela se destaca quando combinada com funções embutidas como int, str, float e len, onde produz o código mais legível e rápido. Com funções lambda, lida com transformações inline de forma limpa. Com múltiplos iteráveis, processa operações elemento por elemento que de outra forma exigiriam zip() e um loop.

Aqui estão as regras para usar map() efetivamente:

• Passe funções embutidas diretamente: map(int, strings) não map(lambda x: int(x), strings).
• Use lambda apenas para transformações simples de expressão única.
• Mude para uma função nomeada quando a transformação precisar de tratamento de erros, múltiplos passos ou documentação.
• Prefira list comprehensions quando precisar filtrar ou quando a expressão for mais clara inline.
• Lembre-se de que map() retorna um iterador preguiçoso de uso único -- converta para list() quando precisar reutilizar ou inspecionar resultados.
• Encadeie chamadas map() para pipelines de múltiplos passos sem criar listas intermediárias.

map() não é um substituto para list comprehensions, e list comprehensions não são um substituto para map(). Eles se sobrepõem mas servem forças diferentes. O melhor código Python usa cada um onde se encaixa naturalmente: map() para aplicar funções existentes, list comprehensions para expressões e filtragem, e expressões geradoras para consumo preguiçoso de passagem única.