Pandas & NumPy Academy · Aula

Transformação e filtragem com GroupBy

Use transform() para adicionar estatísticas por grupo como uma coluna e filter() para manter apenas os grupos que atendem a uma condição.

Aula 4 de 413 etapas

Transformação e filtragem com GroupBy é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 4 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.

Além da agregação

Depois de dominar agg(), surge naturalmente a pergunta: e se o senhor quiser manter todas as linhas originais, mas enriquecê-las com estatísticas no nível do grupo? Ou manter apenas os grupos que atendem a uma condição? É nesse ponto que entram transform() e filter(). Esses dois métodos ampliam o GroupBy para além de simples resumos, abrangendo a criação de atributos e a seleção de dados.

Entendendo transform()

transform() aplica uma função a cada grupo e retorna um resultado com o mesmo formato do DataFrame original — um valor para cada linha original. O resultado do grupo é retransmitido para cada linha pertencente a esse grupo. Isso torna o método ideal para adicionar estatísticas no nível do grupo como novas colunas sem alterar a quantidade de linhas.

import pandas as pd

df = pd.DataFrame({
    'dept':   ['Eng', 'HR', 'Eng', 'HR', 'Eng'],
    'salary': [90000, 60000, 95000, 62000, 88000]
})

# Add a column with each employee's department average salary
df['dept_avg'] = df.groupby('dept')['salary'].transform('mean')
print(df)
#    dept  salary    dept_avg
# 0   Eng   90000  91000.000
# 1    HR   60000  61000.000
# 2   Eng   95000  91000.000
# 3    HR   62000  61000.000
# 4   Eng   88000  91000.000

Casos de uso comuns de transform()

Entre as aplicações comuns de transform() estão: adicionar a média do grupo para normalizar valores; adicionar a soma do grupo para calcular o percentual do total correspondente a cada linha; e adicionar a classificação no grupo para verificar como cada integrante se compara aos demais dentro do grupo. Tudo isso preserva o formato e o índice originais, tornando o resultado imediatamente utilizável junto às colunas originais.

# Percentage of each employee's salary within their department total
df['pct_of_dept'] = (
    df['salary'] / df.groupby('dept')['salary'].transform('sum') * 100
).round(1)
print(df[['dept', 'salary', 'pct_of_dept']])
# dept  salary  pct_of_dept
# Eng   90000        33.1
# HR    60000        49.2
# Eng   95000        34.9

Usando uma função personalizada em transform()

Assim como agg(), transform() aceita qualquer função invocável, além de nomes de texto. A função recebe uma Series de valores de um grupo e deve retornar uma Series com o mesmo comprimento ou um escalar, que será então retransmitido. Retornar um escalar é o caso de uso mais comum — retornar uma Series com comprimento diferente causará um erro.

# Z-score normalisation within each department
def zscore(s):
    return (s - s.mean()) / s.std()

df['salary_zscore'] = df.groupby('dept')['salary'].transform(zscore)
print(df[['dept', 'salary', 'salary_zscore']].round(2))
# dept  salary  salary_zscore
# Eng   90000          -0.51
# HR    60000          -0.71
# Eng   95000           1.03

agg() e transform() lado a lado

A principal diferença é a seguinte: agg() reduz a quantidade de linhas, com uma por grupo, enquanto transform() preserva a quantidade de linhas, com uma por linha original. Use agg() para criar uma tabela de resumo. Use transform() para adicionar informações no nível do grupo como uma nova coluna de atributos no DataFrame original.

g = df.groupby('dept')['salary']

# agg: 2 rows (one per unique dept)
print(g.agg('mean'))
# dept
# Eng    91000.0
# HR     61000.0

# transform: 5 rows (one per original row)
print(g.transform('mean'))
# 0    91000.0
# 1    61000.0
# 2    91000.0
# 3    61000.0
# 4    91000.0

Entendendo filter()

filter() mantém ou descarta grupos inteiros com base em uma função booleana. O senhor passa uma função que recebe um sub-DataFrame de um grupo e retorna True (manter o grupo) ou False (descartar o grupo). O resultado é um subconjunto do DataFrame original contendo apenas as linhas dos grupos aprovados no teste.

df2 = pd.DataFrame({
    'dept':   ['Eng', 'HR', 'Eng', 'HR', 'Eng', 'Legal'],
    'salary': [90000, 60000, 95000, 62000, 88000, 70000]
})

# Keep only departments with at least 2 employees
big_depts = df2.groupby('dept').filter(lambda g: len(g) >= 2)
print(big_depts)
# dept, salary rows: Eng(3) and HR(2) remain; Legal(1) dropped

Filtrando pelo valor agregado do grupo

Um uso muito comum de filter() é manter grupos cujo valor agregado atenda a um limite. Por exemplo, manter apenas os departamentos em que o salário médio ultrapassa uma meta ou apenas as categorias de produtos com vendas totais acima de um mínimo. Isso permite remover grupos com baixo volume antes de continuar a análise.

# Keep only departments where average salary > 80000
high_paying = df2.groupby('dept').filter(
    lambda g: g['salary'].mean() > 80000
)
print(high_paying)
#    dept  salary
# 0   Eng   90000
# 2   Eng   95000
# 4   Eng   88000
# (HR avg is 61000, filtered out)

Combinando transform() e filter()

O senhor pode aplicar transform() e filter() em sequência para enriquecer seus dados e depois restringi-los. Primeiro, use filter() para remover grupos irrelevantes; em seguida, use transform() no resultado filtrado para adicionar atributos no nível do grupo. A combinação produz um subconjunto limpo e rico em atributos, pronto para modelagem ou elaboração de relatórios.

# Step 1: keep only large departments
filtered = df2.groupby('dept').filter(lambda g: len(g) >= 2)

# Step 2: add group mean salary to the filtered result
filtered = filtered.copy()
filtered['dept_avg'] = filtered.groupby('dept')['salary'].transform('mean')
print(filtered)

transform() para preencher valores anteriores dentro dos grupos

transform() também é útil com funções não numéricas. Um padrão comum é preencher valores ausentes dentro de um grupo usando o preenchimento progressivo ou a mediana do grupo, o que é muito melhor que um preenchimento global. Passe uma lambda que chame fillna() na Series do grupo, e o resultado terá o mesmo índice do DataFrame original.

import numpy as np

df3 = pd.DataFrame({
    'dept':   ['Eng', 'Eng', 'HR', 'HR', 'Eng'],
    'salary': [90000, np.nan, 60000, np.nan, 88000]
})

# Fill NaN with the group mean
df3['salary_filled'] = df3.groupby('dept')['salary'].transform(
    lambda s: s.fillna(s.mean())
)
print(df3)

Padrão prático: posição relativa

Um caso de uso empresarial muito útil é calcular a posição de cada linha em relação ao seu grupo. Ao combinar transform() com operações aritméticas, o senhor pode adicionar colunas como: salário menos a média do grupo (desvio); salário como fração do total do grupo; ou um indicador booleano que mostra se esse funcionário ganha acima da mediana do grupo. Esses atributos são extremamente úteis para painéis e modelos de aprendizado de máquina.

df['dept_total'] = df.groupby('dept')['salary'].transform('sum')
df['pct_of_total'] = (df['salary'] / df['dept_total'] * 100).round(1)
df['above_avg'] = df['salary'] > df.groupby('dept')['salary'].transform('mean')
print(df[['dept', 'salary', 'pct_of_total', 'above_avg']])

Considerações de desempenho

Tanto transform() quanto filter(), quando usados com funções integradas na forma de texto, são rápidos porque utilizam caminhos de execução otimizados. No entanto, quando o senhor passa uma lambda ou uma função personalizada em Python, o Pandas precisa chamar essa função uma vez por grupo, o que pode ser lento em dados com muitos grupos. Para obter o máximo desempenho em grandes conjuntos de dados, verifique se a sua lógica personalizada pode ser expressa usando, em vez disso, uma função integrada na forma de texto.

# Slower: custom lambda (called once per group)
df['dept_mean_slow'] = df.groupby('dept')['salary'].transform(lambda s: s.mean())

# Faster: built-in string shortcut (vectorised C path)
df['dept_mean_fast'] = df.groupby('dept')['salary'].transform('mean')

# Both give identical results, but the built-in is significantly faster

Verificação rápida

Teste sua compreensão de transform() e filter() do GroupBy apresentados nesta lição.

Recapitulação da lição

Nesta lição, o senhor aprendeu: transform() retorna estatísticas do grupo retransmitidas até a quantidade de linhas original, sendo ideal para adicionar atributos no nível do grupo; filter() mantém ou remove grupos inteiros com base em uma condição booleana; e a combinação de ambos permite criar conjuntos de dados ricos e filtrados para análises posteriores. A seguir, exploraremos como combinar DataFrames usando pd.concat.

Grátis para começar

Aprenda Python com um tutor de IA — grátis

Escreva e execute código real no seu navegador, obtenha ajuda instantânea de um tutor de IA 24/7 e continue de onde parou na web ou no app.

Cursos
30
Aulas
120

Perguntas Frequentes

A aula “Transformação e filtragem com GroupBy” é grátis?

Sim — o texto completo de “Transformação e filtragem com GroupBy” é 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 “Transformação e filtragem com GroupBy”?

Use transform() para adicionar estatísticas por grupo como uma coluna e filter() para manter apenas os grupos que atendem a uma condição. 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 4 de 4.

Quanto tempo leva a aula “Transformação e filtragem com GroupBy”?

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. O padrão Dividir-Aplicar-Combinar
  2. GroupBy com uma ou várias chaves
  3. O método agg()
  4. Transformação e filtragem com GroupBy
← Voltar para Pandas & NumPy Academy