0Pricing
Pandas & NumPy Academy · Aula

map() e applymap() para operações elemento a elemento

Aplique uma função a cada elemento de uma Series com map() e a cada célula de um DataFrame com applymap().

map() e applymap() para operações elemento a elemento é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Pandas & NumPy Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Pandas & NumPy Academy inclui 4 aulas no total.

Visão geral de Series.map()

Series.map() aplica uma função, um dicionário ou outra Series a cada elemento de uma Series e retorna uma nova Series. Diferentemente de apply(), que pode receber objetos complexos, map() sempre opera sobre valores escalares individuais. É a ferramenta padrão para codificar valores categóricos, consultar rótulos em uma tabela de mapeamento ou aplicar uma transformação simples elemento a elemento.

import pandas as pd

codes = pd.Series(['N', 'S', 'E', 'N', 'W'])
region_names = {'N': 'North', 'S': 'South', 'E': 'East', 'W': 'West'}

names = codes.map(region_names)
print(names)

map() com uma função

Passe uma função, incluindo uma lambda, para map() quando a transformação envolver lógica, e não uma tabela de consulta. A função recebe um escalar por vez, portanto não pode acessar outras linhas ou colunas. Para uma atribuição simples de rótulos condicionais, map() com uma função é mais claro do que um laço, mas mais lento do que np.where() em Series grandes.

prices = pd.Series([5.0, 25.0, 80.0, 150.0])

category = prices.map(lambda p: 'budget' if p < 20 else 'mid' if p < 100 else 'premium')
print(category)

map() versus replace()

Tanto map() quanto replace() podem substituir valores usando um dicionário. A principal diferença é que map() retorna NaN para qualquer valor que não seja encontrado no dicionário, a menos que você use fillna() depois, enquanto replace() mantém inalterados os valores sem correspondência. Use replace() quando quiser alterar apenas valores específicos e manter todo o restante como está.

s = pd.Series(['A', 'B', 'C', 'D'])
map_dict = {'A': 'Alpha', 'B': 'Beta'}

print('map():', s.map(map_dict).tolist())      # C,D → NaN
print('replace():', s.replace(map_dict).tolist())  # C,D → unchanged

map() com uma Series (consulta de rótulos)

Você pode passar outra Series para map() como uma tabela de consulta: os valores da Series que chama o método são usados como chaves para consultar valores no índice da Series fornecida como argumento. Esta é uma forma concisa de unir uma tabela de consulta sem uma chamada completa a merge() — funciona como uma consulta vetorizada de dicionário em que a tabela de consulta é indexada pela chave.

prices_lookup = pd.Series(
    [10.0, 25.0, 50.0],
    index=['SKU-001', 'SKU-002', 'SKU-003']
)

orders = pd.Series(['SKU-002', 'SKU-001', 'SKU-003', 'SKU-001'])
order_prices = orders.map(prices_lookup)
print(order_prices)

DataFrame.applymap() para operações célula a célula

DataFrame.applymap(), chamado de DataFrame.map() no Pandas 2.1+, aplica uma função a cada célula individual de um DataFrame. Diferentemente de apply(axis=0), que recebe uma coluna completa, applymap() recebe um escalar por vez. É útil para formatar todas as células de maneira uniforme — por exemplo, arredondar cada célula numérica para 2 casas decimais ou converter cada célula de texto para minúsculas.

df = pd.DataFrame({
    'a': [1.234, 5.678, 9.012],
    'b': [3.456, 7.890, 2.345]
})

# Round every cell to 1 decimal place
df_rounded = df.applymap(lambda x: round(x, 1))
print(df_rounded)

applymap() para formatação de texto

Aplique uma formatação de texto consistente a cada célula de um DataFrame com textos variados — por exemplo, colocando todos os valores em formato de título ou convertendo None em uma cadeia de caracteres vazia. applymap(str.strip) remove os espaços em branco de todas as células do DataFrame inteiro com uma única chamada, o que é muito mais conciso do que percorrer as colunas e aplicar .str.strip() individualmente a cada uma.

df_str = pd.DataFrame({
    'name': [' Alice ', 'Bob  ', '  Carol'],
    'city': ['new york ', ' london', 'paris  ']
})

df_clean = df_str.applymap(str.strip)
print(df_clean)

applymap() para formatação monetária

Ao preparar um DataFrame para exibição em um relatório, formate as células numéricas como cadeias de caracteres monetárias usando applymap(). Isso converte os números em cadeias prontas para exibição sem modificar os tipos de dados subjacentes — a transformação serve apenas para a saída final. Aplique-a como última etapa antes de chamar to_excel() ou to_html() para exportar a tabela formatada.

revenue_table = pd.DataFrame({
    'North': [12300.0, 9800.0],
    'South': [7400.0, 11200.0]
}, index=['Q1', 'Q2'])

formatted = revenue_table.applymap(lambda x: f'${x:,.0f}')
print(formatted)

Pandas 2.1: applymap renomeado para map

No Pandas 2.1, DataFrame.applymap() foi renomeado para DataFrame.map() para manter a consistência com Series.map(). O antigo applymap() ainda funciona, mas gera um aviso de descontinuação. Em código de produção, verifique sua versão do Pandas e use df.map(func) se estiver usando a versão 2.1 ou posterior, para evitar avisos de descontinuação em versões futuras.

import pandas as pd

print('Pandas version:', pd.__version__)

# Forward-compatible pattern:
if hasattr(pd.DataFrame, 'map'):
    df_clean = df_str.map(str.strip)  # Pandas 2.1+
else:
    df_clean = df_str.applymap(str.strip)  # Pandas < 2.1

print(df_clean)

map() para codificar características categóricas

Os modelos de aprendizado de máquina exigem entradas numéricas, portanto as colunas categóricas precisam ser codificadas. Use map() com um dicionário de codificação inteira para converter as categorias em números ordinais antes de passar um DataFrame para um modelo. Para categorias nominais sem uma ordem natural, prefira pd.get_dummies() ou o OneHotEncoder do scikit-learn.

size_order = {'small': 0, 'medium': 1, 'large': 2, 'enterprise': 3}

df['size_encoded'] = df['order_size'].map(size_order)
print(df[['order_size', 'size_encoded']])

Encadeando map() para uma consulta em várias etapas

Encadeie duas chamadas a map() quando precisar de uma consulta em dois níveis: primeiro mapeie um código para uma chave intermediária e, depois, mapeie a chave intermediária para um rótulo final. Por exemplo, mapeie o SKU do produto para um código de categoria e, em seguida, mapeie o código de categoria para o nome da categoria. Encadear duas chamadas a map() é mais claro do que usar um dicionário aninhado ou uma união seguida de outra união.

sku_to_cat_code = {'SKU-001': 'C1', 'SKU-002': 'C2', 'SKU-003': 'C1'}
cat_code_to_name = {'C1': 'Electronics', 'C2': 'Apparel'}

skus = pd.Series(['SKU-001', 'SKU-002', 'SKU-003'])
cat_names = skus.map(sku_to_cat_code).map(cat_code_to_name)
print(cat_names)

Tratamento de valores nulos elemento a elemento com map

Ao usar map(func), a função é chamada até mesmo para valores NaN, o que pode causar TypeError se a função não tratar None. Envolva a função com uma verificação de nulo usando pd.isna(x) ou use o parâmetro na_action='ignore' em map() para ignorar valores NaN e mantê-los como NaN na saída, sem chamar a função.

s = pd.Series([1.0, None, 3.0, None, 5.0])

# na_action='ignore' skips NaN values
result = s.map(lambda x: x * 2, na_action='ignore')
print(result)

Verificação rápida

Teste sua compreensão dos conceitos de Análise de Dados desta lição.

Resumo da lição

Nesta lição, você aprendeu: a usar Series.map() para consultas escalares com funções e dicionários, a usar DataFrame.applymap()/map() para formatação célula a célula em todas as colunas e a entender a diferença entre map() e replace() no tratamento de valores sem correspondência. A seguir, exploraremos o encadeamento de métodos com pipe() para criar pipelines de transformação legíveis.

Perguntas Frequentes

A aula “map() e applymap() para operações elemento a elemento” é grátis?

Sim — o texto completo de “map() e applymap() para operações elemento a elemento” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Pandas & NumPy Academy, atualize para CoddyKit PRO. O curso de Pandas & NumPy Academy inclui 4 aulas no total.

O que vou aprender em “map() e applymap() para operações elemento a elemento”?

Aplique uma função a cada elemento de uma Series com map() e a cada célula de um DataFrame com applymap(). Você pratica Pandas & NumPy Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Pandas & NumPy Academy?

Nenhuma experiência prévia é necessária. Pandas & NumPy Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “map() e applymap() para operações elemento a elemento”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Pandas & NumPy Academy?

Sim. Cada aula de Pandas & NumPy Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. apply() em colunas e linhas
  2. apply() com GroupBy
  3. map() e applymap() para operações elemento a elemento
  4. Encadeamento de métodos com pipe()
← Voltar para Pandas & NumPy Academy